websocket的使用-后端开发-java+springboot

Dear 丶 2023-10-07 22:11 2阅读 0赞

#### 前言： ####

websocket 可用于客户端与服务端进行双向通信，比http的服务优势在于可主动向客户端发送信息

本文示例是通过浏览器访问时的session进行演示，可以应用且不限于

1.通过seesion指定某个客户端进行推送信息

2.可以调用群发方法向所有客户端进行推送信息

3.在客户端连接时就推送相关所需要的数据

**目录**

前言：

1.导入相关jar包

2.添加类

websocket的使用比较简单，可分为两个步骤

#### 1.导入相关jar包 ####

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-websocket</artifactId>
                <version>5.1.8.RELEASE</version>
            </dependency>

#### 2.添加类 ####

配置类

package com.xinke.combustibleIdentification.config.websocket;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    import javax.websocket.server.ServerEndpointConfig;
    
    @Configuration
    public class WebSocketConfig extends ServerEndpointConfig.Configurator {
        /**
         * 给spring容器注入这个ServerEndpointExporter对象
         * 相当于xml：
         * <beans>
         * <bean/>
         * </beans>
         * <p>
         * 检测所有带有@serverEndpoint注解的bean并注册他们。
         *
         * @return
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }

使用类

package com.xinke.combustibleIdentification.websocket;
    
    import com.xinke.combustibleIdentification.config.websocket.WebSocketConfig;
    import com.xinke.combustibleIdentification.service.PushService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.Resource;
    import javax.websocket.*;
    import javax.websocket.server.ServerEndpoint;
    import java.io.IOException;
    import java.util.concurrent.CopyOnWriteArraySet;
    import java.util.concurrent.atomic.AtomicInteger;
    
    @ServerEndpoint(value = "/ws/asset", configurator = WebSocketConfig.class)
    @Component
    public class WebSocketServer {
    
        @PostConstruct
        public void init() {
            System.out.println("websocket 加载");
        }
    
        // 需要连接时就推送方法的话需导入相关的推送类
        // private static PushService pushService;
        // @Resource
        // public void setApplicationContext(PushService pushService){
        //    WebSocketServer.pushService = pushService;
        // }
    
        private static Logger log = LoggerFactory.getLogger(WebSocketServer.class);
        private static final AtomicInteger OnlineCount = new AtomicInteger(0);
        // concurrent包的线程安全Set，用来存放每个客户端对应的Session对象。
        private static CopyOnWriteArraySet<Session> SessionSet = new CopyOnWriteArraySet<Session>();
    
    
        /**
         * 连接建立成功调用的方法
         */
        @OnOpen
        public void onOpen(Session session) {
            int cnt = OnlineCount.incrementAndGet(); // 在线数加1
            log.info("有连接加入，当前连接数为：{}", cnt);
            SessionSet.add(session);
            SendMessage(session, "连接成功");
            // 客户端连接就进行调用需要推送的方法
            // pushService.warningPush(null,session);
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose(Session session) {
            SessionSet.remove(session);
            int cnt = OnlineCount.decrementAndGet();
            System.out.println("客户端sessionId" + session.getId());
            log.info("有连接关闭，当前连接数为：{}", cnt);
        }
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param message
         *            客户端发送过来的消息
         */
        @OnMessage
        public void onMessage(String message, Session session) {
            System.out.println("收到客户端发来的消息：" + message + ";客户端sessionId" + session.getId());
            SendMessage(session, "收到客户端发来的消息：" + message + ";客户端sessionId" + session.getId());
    
        }
    
        /**
         * 出现错误
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            log.error("发生错误：{}，Session ID：{}",error.getMessage(),session.getId());
            error.printStackTrace();
        }
    
        /**
         * 发送消息，实践表明，每次浏览器刷新，session会发生变化。
         * @param session
         * @param message
         */
        public static void SendMessage(Session session, String message) {
            try {
    //            session.getBasicRemote().sendText(String.format("%s (From Server，Session ID=%s)",message,session.getId()));
                session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                log.error("发送消息出错：{}", e.getMessage());
                e.printStackTrace();
            }
        }
    
        /**
         * 群发消息
         * @param message
         * @throws IOException
         */
        public static void BroadCastInfo(String message) throws IOException {
            log.info("群发发送消息：{}",message);
            for (Session session : SessionSet) {
                if(session.isOpen()){
                    SendMessage(session, message);
                }
            }
        }
    
        /**
         * 指定Session发送消息
         * @param sessionId
         * @param message
         * @throws IOException
         */
        public static void SendMessage(String message,String sessionId) throws IOException {
            Session session = null;
            for (Session s : SessionSet) {
                if(s.getId().equals(sessionId)){
                    session = s;
                    break;
                }
            }
            if(session!=null){
                SendMessage(session, message);
            }
            else{
                log.warn("没有找到你指定ID的会话：{}",sessionId);
            }
        }
    }

添加完成后可启动服务去测试页面进行测试

[点击进行测试][Link 1]

有用点赞收藏

[Link 1]: http://www.jsons.cn/websocket/