Springboot整合Websocket

最新推荐文章于 2023-08-29 10:51:36 发布

王钧石的技术博客

最新推荐文章于 2023-08-29 10:51:36 发布

阅读量1.1k

点赞数

分类专栏： websocket 文章标签： spring boot websocket

本文链接：https://blog.csdn.net/weixin_43830765/article/details/129412755

版权

websocket 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

什么是WebSocket：

WebSocket是一种基于TCP协议的双向通信协议，可以在客户端和服务器之间建立持久连接，并通过这个连接实现实时的双向通信。相对于HTTP协议，WebSocket协议具有更低的延迟和更高的带宽利用率，适用于实时通信、游戏、视频流等场景。

websocket的原理:

websocket基于http协议与客户端握手，建立连接成功后，连接会一直保持
http请求升级：
客户端向服务器端建立websocket连接时，连接握手阶段是基于http请求的，客户端会在请求头中加入Upgrade: websocket
提示服务器端要将http请求升级成websocket请求。
在接收到客户端的Upgrade: websocket请求升级头后，如果服务器端支持websocket请求协议，同意请求升级，则会在相应头中也加入
Upgrade: websocket 响应头，表示同意建立连接。
在建立连接的握手阶段：
客户端在http的请求头中发送哈希值：
Sec-Websocket-key: z8kjKoVzHeNlR1Y62Q3HHA==
服务端在得到这段哈希值后，返回给客户端另外一个哈希值：
Sec-Websocket-Accept: DSTGGnrmQFph8ZTQWzQQC7CzKcc=
这两个哈希值代表了当前与服务端连接的客户端的唯一标识
http与websocket区别
http只能有客户端发起，服务器端无法主动发起请求
websocket可以由服务器主动发起，推送给客户端
http1.0,1.1版本目前不支持长连接，http2.0支持长连接，但目前市面上大部分工程都只支持http1的协议版本，并没有很好的兼容http2，所以处理长连接实时会话的场景仍然以websocket技术为主。
websocket的应用场景
实时聊天
弹幕
股票实时数据更新
实时位置更新，定位

springboot整合websocket案例:

引入依赖

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-websocket</artifactId>
 </dependency>

构建websocket配置类

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
	
	// 注入拦截器，这个拦截器的作用是在wensocket连接握手阶段对用户进行鉴权，保存session等操作，详细代码解释在下面
    @Autowired
    MutiModeChatWebSocketInterceptor mutiModeChatWebSocketInterceptor;
	// 创建一个消息处理节点的bean，这个bean的作用是在websocket已经建立好连接之后，对服务端与客户端通信的处理，详细代码解释在下面
    @Bean
    public MutiModeChatHandler mutiModeChatHandler(){
        return new MutiModeChatHandler();
    }
    // 实现WebSocketConfigurer接口中的registerWebSocketHandlers方法
	// 注册一个名为/mutiModeChatEndPoint的 websocket节点
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        // 1. 为这个节点添加会话处理的handler(MutiModeChatHandler) 
        registry.addHandler(mutiModeChatHandler(),"/mutiModeChatEndPoint") 
        		// 2. 添加连接这个节点的拦截器(MutiModeChatWebSocketInterceptor)
                .addInterceptors(mutiModeChatWebSocketInterceptor) 
                // 3. 配置该节点允许跨域 setAllowedOrigins("*")
                .setAllowedOrigins("*");
    }
    // 注册一个定时任务的线程池，为什么要配置这个bean,具体原因我也在探究，这点我弄明白后会更新博客
    // 如果不配置在项目启动的时候会报错，报错信息详情在下面
     @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10);
        taskScheduler.initialize();
        return taskScheduler;
    }
}

构建会话管理类，用于保存客户端的连接信息，并对其进行统一管理

@Component
public class WsSessionManager {

    private static Logger log = LoggerFactory.getLogger(WsSessionManager.class);

    /**
     * 保存客户端连接 session
     */
    private static ConcurrentHashMap<String, WebSocketSession> SESSION_POOL = new ConcurrentHashMap<>();

    /**
     * 添加 session
     *
     * @param key
     */
    public static void add(String key, WebSocketSession session) {
        // 添加 session
        SESSION_POOL.put(key, session);
    }

    /**
     * 删除 session,会返回删除的 session
     *
     * @param key
     * @return
     */
    public static WebSocketSession remove(String key) {
        // 删除 session
        return SESSION_POOL.remove(key);
    }


    /**
     * 获得 session
     *
     * @param key
     * @return
     */
    public static WebSocketSession get(String key) {
        // 获得 session
        return SESSION_POOL.get(key);
    }
}

构建 MutiModeChatWebSocketInterceptor 拦截器

@Component
public class MutiModeChatWebSocketInterceptor implements HandshakeInterceptor {
	
	private static Logger log = LoggerFactory.getLogger(MutiModeChatWebSocketInterceptor.class);
	
    /**
     * 握手前
     *
     * @param request
     * @param response
     * @param wsHandler
     * @param attributes
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest request, 
    		ServerHttpResponse response, 
    		WebSocketHandler wsHandler, 
    		Map<String, Object> attributes) throws Exception {

    	log.debug("握手开始");
        // 获得请求参数
        ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
        String user = servletRequest.getServletRequest().getParameter("user");
        String token = servletRequest.getServletRequest().getParameter("token");
        if (!StringUtils.isEmpty(user)) {
            // 放入属性域
            // 每个连接生成唯一ID
            attributes.put("user",user);
            attributes.put("token",token);
            log.debug("用户 token" + token + " 握手成功！");
            return true;
        } else {
            log.debug("用户登录已失效");
            return false;
        }
    }

    /**
     * 握手后
     *
     * @param request
     * @param response
     * @param wsHandler
     * @param exception
     */
    @Override
    public void afterHandshake(ServerHttpRequest request, 
    		ServerHttpResponse response, 
    		WebSocketHandler wsHandler, 
    		Exception exception) {
    	log.debug("握手完成");
    }
}

构建会话处理handler
这里继承 AbstractWebSocketHandler 类，实现websocket的生命周期方法即可

public class MutiModeChatHandler extends AbstractWebSocketHandler {
    private Logger log = LoggerFactory.getLogger(MutiModeChatHandler.class);
 
    /**
     * 接收客户端交互消息
     * @param session
     * @param message
     * @throws Exception
     */
    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        // 获得客户端传来的消息
        String token = (String) session.getAttributes().get("token");
        String user = (String)session.getAttributes().get("user");
        String key = user+"."+token;
        if (WsSessionManager.get(key)==null){
            log.error("用户"+user+"连接异常");
        }else {
            String payload = message.getPayload();
            try {
                JSONObject msg = JSONObject.parseObject(payload);
                log.info("webServer接收到 " + token + " 发送的 " + payload);
                // 发送消息给客户端
                sendMessage(key,user+"的问题已接收");
            }catch (Exception e){
                sendMessage(key,"消息体json结构异常[错误信息:"+e+"]");
            }
        }
    }

    /**
     * 与客户端交互通讯
     * @param key
     * @param message
     */
    private void sendMessage(String key,String message)  {
        try {
            WebSocketMessage msg = new TextMessage(message);
            WebSocketSession webSocketSession = WsSessionManager.get(key);
            webSocketSession.sendMessage(msg);
        }catch (Exception e){
            log.error("会话异常"+e);
        }
    }

    /**
     * 连接建立后添加用户session
     * @param session
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        String token = (String)session.getAttributes().get("token");
        String user = (String)session.getAttributes().get("user");
        String key = user+"."+token;
        WsSessionManager.add(key,session);
        log.info("用户:"+user+"已连接");
    }

    /**
     * 连接关闭后删除会话信息，释放资源
     * @param session
     * @param status
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        String token = (String)session.getAttributes().get("token");
        String user = (String)session.getAttributes().get("user");
        String key = user+"."+token;
        System.out.println(WsSessionManager.get(token) == null);
        if (token != null && WsSessionManager.get(key) != null) {
            // 用户退出，移除缓存
            WsSessionManager.remove(key);
            log.info("[afterConnectionClosed]用户:" + user + "退出");
        }
    }
}

测试程序：
这里我简单编写了一个前端的测试程序来测试会话连接，当然也可以用websocket的在线测试工具进行测试
websocket在线测试网址

下面的测试程序在运行之前，要导入websocket的依赖

npm install -s -g websocket

const WebSocket = require('ws')
// mport * as WebSocket  from 'websocket'
var socket = new WebSocket("ws://localhost:8088/mutiModeChatEndPoint?user=aaa&token=111");

var msg={
    "user":"aaa",
    "token":"111",
    "data":"这是我要问的问题"
}
socket.onopen = function(event) {
    console.log("WebSocket opened.");
    socket.send(JSON.stringify(msg));
};

socket.onmessage = function(event) {
    console.log("Received message: " + event.data);
};

socket.onclose = function(event) {
    console.log("WebSocket closed.");
};

启动springboot服务，在vscode上调试运行js脚本，注意需要安装node环境
调试结果:
服务器端:
在这里插入图片描述
客户端:

程序中的报错与bug,之前提到的TaskScheduler bean的配置报错，如下：

这个问题，能弄清楚后，更新博文，也希望知道原因的大佬指点一下，谢谢啦。
写在最后：
目前websocket有很多封装好的框架比如netty，大家也可以用netty来实现下上面的聊天功能，之后我也会更新几个websocket框架实现案例

王钧石的技术博客

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Springboot整合Websocket

WebSocket是一种基于TCP协议的双向通信协议，可以在客户端和服务器之间建立持久连接，并通过这个连接实现实时的双向通信。相对于HTTP协议，WebSocket协议具有更低的延迟和更高的带宽利用率，适用于实时通信、游戏、视频流等场景。
复制链接

扫一扫