SpringBoot 2.2 使用 Spring 封装注解简易集成 websocket

傷城~ 2023-07-17 09:47 27阅读 0赞

### 文章目录 ###

*   *   *  1 摘要
         *  2 核心 Maven 依赖
         *  3 配置信息
         *  4 核心 Java 类
         *   *  4.1 websocket 会话管理类
             *  4.2 websocket 握手拦截器
             *  4.3 websocket 连接拦截器
             *  4.4 websocket 拦截器配置类
             *  4.5 SpringBoot 应用启动类
         *  5 测试
         *  6 参考资料推荐
         *  7 Github 源码

### 1 摘要 ###

在 SpringBoot 中使用原生注解简易集成 websocket 可参考:

[Spring Boot 2.2 原生注解简易集成 websocket][Spring Boot 2.2 _ websocket]

本文将介绍使用 Spring 封装的注解简易集成 websocket

### 2 核心 Maven 依赖 ###

./demo-websocket-spring/pom.xml

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>

其中 springboot 版本为 `2.2.5.RELEASE`, `${hutool.version}` 版本为 `5.2.3`

### 3 配置信息 ###

./demo-websocket-spring/src/main/resources/application.yml

## config
    
    ## server
    server:
      port: 8201

### 4 核心 Java 类 ###

#### 4.1 websocket 会话管理类 ####

./demo-websocket-spring/src/main/java/com/ljq/demo/springboot/websocketspring/web/SocketSessionManager.java

package com.ljq.demo.springboot.websocketspring.web;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.socket.WebSocketSession;
    
    import java.io.IOException;
    import java.util.concurrent.ConcurrentHashMap;
    
    /** * @Description: websocket 会话管理 * @Author: junqiang.lu * @Date: 2020/3/19 */
    @Slf4j
    public class SocketSessionManager { 
    
        /** * websocket 会话池 */
        private static ConcurrentHashMap<String, WebSocketSession> webSocketSessionMap = new ConcurrentHashMap<>();
    
        /** * 添加 websocket 会话 * * @param key * @param session */
        public static void add(String key, WebSocketSession session) { 
            webSocketSessionMap.put(key, session);
        }
    
        /** * 移除 websocket 会话,并将该会话内容返回 * * @param key * @return */
        public static WebSocketSession remove(String key) { 
            return webSocketSessionMap.remove(key);
        }
    
        /** * 删除 websocket,并关闭连接 * * @param key */
        public static void removeAndClose(String key) { 
            WebSocketSession session = remove(key);
            if (session != null) { 
                try { 
                    session.close();
                } catch (IOException e) { 
                    log.error("Websocket session close exception ",e);
                }
            }
        }
    
        /** * 获取 websocket 会话 * * @param key * @return */
        public static WebSocketSession get(String key) { 
            return webSocketSessionMap.get(key);
        }
    
        /** * 获取会话数量 * * @return */
        public static int count() { 
            return webSocketSessionMap.size();
        }
    
    }

#### 4.2 websocket 握手拦截器 ####

在进行 websocket 握手成功之前进行身份验证

./demo-websocket-spring/src/main/java/com/ljq/demo/springboot/websocketspring/interceptor/SocketInterceptor.java

package com.ljq.demo.springboot.websocketspring.interceptor;
    
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.http.HttpUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.stereotype.Component;
    import org.springframework.web.socket.WebSocketHandler;
    import org.springframework.web.socket.server.HandshakeInterceptor;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /** * @Description: websocket 握手拦截器 * @Author: junqiang.lu * @Date: 2020/3/19 */
    @Slf4j
    @Component
    public class SocketInterceptor implements HandshakeInterceptor { 
    
        private static final String TOKEN_FIELD = "token";
    
        /** * websocket 握手之前 * * @param serverHttpRequest * @param serverHttpResponse * @param webSocketHandler * @param map * @return * @throws Exception */
        @Override
        public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse,
                                       WebSocketHandler webSocketHandler, Map<String, Object> map) throws Exception { 
            log.debug("websocket starts handshaking");
            // 获取请求参数
            HashMap<String, String> paramMap = HttpUtil.decodeParamMap(serverHttpRequest.getURI().getQuery(), "utf-8");
            String token = paramMap.get(TOKEN_FIELD);
            if (StrUtil.isNotBlank(token)) { 
                map.put("token", token);
                log.debug("用户 [ {} ]握手成功", token);
                return true;
            }
            log.debug("用户登录已失效");
            return false;
        }
    
        /** * websocket 握手之后 * * @param serverHttpRequest * @param serverHttpResponse * @param webSocketHandler * @param e */
        @Override
        public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse,
                                   WebSocketHandler webSocketHandler, Exception e) { 
            log.debug("握手完成!");
        }
    }

#### 4.3 websocket 连接拦截器 ####

在 websocket 握手成功之后，管理已经创建的 websocket 连接

./demo-websocket-spring/src/main/java/com/ljq/demo/springboot/websocketspring/interceptor/SocketAuthHandler.java

package com.ljq.demo.springboot.websocketspring.interceptor;
    
    import com.ljq.demo.springboot.websocketspring.web.SocketSessionManager;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    import org.springframework.web.socket.CloseStatus;
    import org.springframework.web.socket.TextMessage;
    import org.springframework.web.socket.WebSocketSession;
    import org.springframework.web.socket.handler.TextWebSocketHandler;
    
    import java.time.LocalDateTime;
    import java.util.Objects;
    
    /** * @Description: websocket 连接拦截器 * @Author: junqiang.lu * @Date: 2020/3/19 */
    @Slf4j
    @Component
    public class SocketAuthHandler extends TextWebSocketHandler { 
    
        private static final String TOKEN_FIELD = "token";
    
        /** * 握手成功之后 * * @param session * @throws Exception */
        @Override
        public void afterConnectionEstablished(WebSocketSession session) throws Exception { 
            Object token = session.getAttributes().get(TOKEN_FIELD);
            if (Objects.nonNull(token)) { 
                // 用户连接成功,缓存用户会话
                log.debug("用户[ {} ]创建连接", token);
                SocketSessionManager.add(String.valueOf(token), session);
            } else { 
                throw new RuntimeException("用户登录已失效");
            }
        }
    
        /** * 接收客户端消息 * * @param session * @param message * @throws Exception */
        @Override
        protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { 
            // 读取客户端消息
            Object token = session.getAttributes().get(TOKEN_FIELD);
            String payload = message.getPayload();
            log.debug("收到用户 [{}] 的消息,消息内容为: {}",token, payload);
    
            StringBuilder responseBuilder = new StringBuilder();
            responseBuilder.append("服务端已接收到用户 [").append(token).append("] 的消息,消息内容为:");
            responseBuilder.append(payload).append(",当前服务器时间: ");
            responseBuilder.append(LocalDateTime.now());
    
            session.sendMessage(new TextMessage(responseBuilder.toString()));
        }
    
        @Override
        public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { 
            Object token = session.getAttributes().get(TOKEN_FIELD);
            if (Objects.nonNull(token)) { 
                log.debug("用户 [{}] 断开连接", token);
                SocketSessionManager.remove(String.valueOf(token));
            }
        }
    }

方法说明:

`afterConnectionEstablished()` 方法是在 websocket 握手成功之后，创建 socket 连接的时候触发，等价于 socket 的原生注解 `@OnOpen`

`handleTextMessage()` 方法是在客户端向服务端发送**文本**消息的时候触发，等价于 socket 的原生注解 `@OnMessage` 。Spring 封装的还有 `handleMessage()` 方法，所有客户端发送消息都会触发该方法，无论什么类型的数据。

`afterConnectionClosed()` 方法是在客户端(请求)断开连接的时候触发，等价于 socket 的原生注解 `@OnClose`

#### 4.4 websocket 拦截器配置类 ####

./demo-websocket-spring/src/main/java/com/ljq/demo/springboot/websocketspring/interceptor/SocketConfig.java

package com.ljq.demo.springboot.websocketspring.interceptor;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.config.annotation.EnableWebSocket;
    import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
    import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
    
    /** * @Description: websocket 拦截器配置 * @Author: junqiang.lu * @Date: 2020/3/19 */
    @Configuration
    @EnableWebSocket
    public class SocketConfig implements WebSocketConfigurer { 
    
        @Autowired
        private SocketAuthHandler socketAuthHandler;
        @Autowired
        private SocketInterceptor socketInterceptor;
    
        private static final String WEB_SOCKET_PATH = "socketSpring";
    
        /** * * @param webSocketHandlerRegistry */
        @Override
        public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) { 
            webSocketHandlerRegistry.addHandler(socketAuthHandler, WEB_SOCKET_PATH)
                    .addInterceptors(socketInterceptor)
                    .setAllowedOrigins("*");
        }
    }

#### 4.5 SpringBoot 应用启动类 ####

./demo-websocket-spring/src/main/java/com/ljq/demo/springboot/websocketspring/DemoWebsocketSpringApplication.java

package com.ljq.demo.springboot.websocketspring;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /** * @author junqiang.lu */
    @SpringBootApplication(scanBasePackages = { "com.ljq.demo.springboot"})
    public class DemoWebsocketSpringApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(DemoWebsocketSpringApplication.class, args);
        }
    
    }

### 5 测试 ###

在线 websocket 测试地址:

[WebSocket在线测试工具][WebSocket]

[在线WebSocket测试工具][WebSocket 1]

启动项目,在测试网站输入 websocket 地址:

ws://127.0.0.1:8201/socketSpring?token=demo1

`127.0.0.1` 为本机 ip 地址，可根据需要自行更改 ip 地址

`demo1` 为用户名,测试时可自行更换

连接成功，无返回结果,控制台日志:

发送消息，消息内容为:

55555

返回结果为:

服务端已接收到用户 [demo1] 的消息,消息内容为:55555,当前服务器时间: 2020-03-20T15:01:20.990

控制台日志为:

2020-03-20 15:01:20 | DEBUG | http-nio-8201-exec-6 | c.l.d.s.w.interceptor.SocketAuthHandler 55| 收到用户 [demo1] 的消息,消息内容为: 55555

断开连接，无返回结果，控制台日志为:

2020-03-20 15:03:08 | DEBUG | http-nio-8201-exec-7 | c.l.d.s.w.interceptor.SocketAuthHandler 69| 用户 [demo1] 断开连接

至此，在 SpringBoot 中使用 Spring 封装注解简易集成 websocket 已实现

### 6 参考资料推荐 ###

[A Guide to the Java API for WebSocket][]

[Spring Boot系列十六 WebSocket简介和spring boot集成简单消息代理][Spring Boot_ WebSocket_spring boot]

[【websocket】spring boot 集成 websocket 的四种方式][websocket_spring boot _ websocket]

[WebSocket在线测试工具][WebSocket]

[在线WebSocket测试工具][WebSocket 1]

### 7 Github 源码 ###

**Gtihub 源码地址** : [https://github.com/Flying9001/springBootDemo][https_github.com_Flying9001_springBootDemo]

个人公众号:**404Code**,分享半个互联网人的技术与思考，感兴趣的可以关注.  
![404Code][]

[Spring Boot 2.2 _ websocket]: https://blog.csdn.net/Mrqiang9001/article/details/104949105
[WebSocket]: http://ws.douqq.com
[WebSocket 1]: http://www.toolnb.com/tools/webSocketTools.html
[A Guide to the Java API for WebSocket]: https://www.baeldung.com/java-websockets
[Spring Boot_ WebSocket_spring boot]: https://blog.csdn.net/hry2015/article/details/79829616
[websocket_spring boot _ websocket]: https://juejin.im/post/5db05df76fb9a0206062b6d4
[https_github.com_Flying9001_springBootDemo]: https://github.com/Flying9001/springBootDemo
[404Code]: /images/20230528/c0dacc73980443b0904df36a60d0bb38.png