Spring封装的原生WebSocket使用,带组的实现

最新推荐文章于 2024-01-20 12:09:03 发布

幸识SQ

最新推荐文章于 2024-01-20 12:09:03 发布

阅读量103

点赞数

文章标签： spring websocket java

本文链接：https://blog.csdn.net/weixin_57228276/article/details/133627965

版权

前言

为了和TIO来进行对比websocket的简易程度,我这篇就是写一下Spring原生的webSocket的正常操作

拿来对比就可以说说优劣性

正文

首先还是导入原生依赖,这里不需要写版本号

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

1.加入消息处理器

package com.xssq.handle;

import com.xssq.service.ApiService;
import com.xssq.utils.WsSessionManager;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**
* web套接字处理程序
*
* @author xssq
* @version 1.0.0
* @date 2023/10/05
* @wisdom 你可以不会，但你不能不知道
*/
@Component
public class WebSocketHandler extends TextWebSocketHandler {
   @Autowired
   private ApiService apiService;
   /**
    * 连接建立后
    * socket 建立成功事件
    *
    * @param session 会话
    */
   @Override
   public void afterConnectionEstablished(WebSocketSession session) {
       Object token = session.getAttributes().get("token");
       if (token != null) {
           // 用户连接成功，放入在线用户缓存
           WsSessionManager.add(token.toString(), session);
       } else {
           throw new RuntimeException("用户登录已经失效!");
       }
   }

   /**
    * 处理文本消息
    * 接收消息事件
    *
    * @param session 会话
    * @param message 信息
    * @throws Exception 例外
    */
   @Override
   protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
       apiService.apiGet();
       // 获得客户端传来的消息
       String payload = message.getPayload();
       Object token = session.getAttributes().get("token");
       System.out.println("server 接收到 " + token + " 发送的 " + payload);
       session.sendMessage(new TextMessage("server 发送给 " + token + " 消息 " + payload + " " + LocalDateTime.now()));
   }

   /**
    * 连接关闭后
    * socket 断开连接时
    *
    * @param session 会话
    * @param status  状态
    */
   @Override
   public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
       Object token = session.getAttributes().get("token");
       if (token != null) {
           // 用户退出，移除缓存
           WsSessionManager.remove(token.toString());
       }
   }
}

2.加入握手拦截器

package com.xssq.Interceptor;

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpUtil;
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.Map;

/**
* web套接字拦截器
*
* @author xssq
* @version 1.0.0
* @date 2023/10/05
* @wisdom 你可以不会，但你不能不知道
*/
@Component
public class WebSocketInterceptor implements HandshakeInterceptor {
   /**
    * 握手之前
    *
    * @param request    请求
    * @param response   响应
    * @param wsHandler  ws处理程序
    * @param attributes 属性
    * @return boolean
    * @throws Exception 例外
    */
   @Override
   public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
       System.out.println("握手开始");
       // 获得请求参数
       Map<String, String> paramMap = HttpUtil.decodeParamMap(request.getURI().getQuery(), CharsetUtil.CHARSET_UTF_8);
       String token = paramMap.get("token");
       if (StrUtil.isNotBlank(token)) {
           // 放入属性域
           attributes.put("token", token);
           System.out.println("用户 token " + token + " 握手成功！");
           return true;
       }
       System.out.println("用户登录已失效");
       return false;
   }

   /**
    * 握手后
    *
    * @param request   请求
    * @param response  响应
    * @param wsHandler ws处理程序
    * @param exception 例外
    */
   @Override
   public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
       System.out.println("握手完成");
   }
}

3.握手拦截器创建完成后,再创建一个用户的会话管理

package com.xssq.utils;

import org.springframework.web.socket.WebSocketSession;

import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

/**
* ws会话管理器
*
* @author xssq
* @version 1.0.0
* @date 2023/10/05
* @wisdom 你可以不会，但你不能不知道
*/
public class WsSessionManager {
   /**
    * 保存连接 session 的地方
    */
   public 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);
   }

   /**
    * 删除并同步关闭连接
    *
    * @param key
    */
   public static void removeAndClose(String key) {
       WebSocketSession session = remove(key);
       if (session != null) {
           try {
               // 关闭连接
               session.close();
           } catch (IOException e) {
               // todo: 关闭出现异常处理
               e.printStackTrace();
           }
       }
   }

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

4.创建组连接池管理

package com.xssq.utils;

import cn.hutool.core.util.IdUtil;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;

import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

/**
* 组ws会话管理器
*
* @author xssq
* @version 1.0.0
* @date 2023/10/07
* @wisdom 你可以不会，但你不能不知道
*/
public class GroupWsSessionManager {

   /**
    * 组会话池
    */
   public static ConcurrentHashMap<String, ConcurrentHashMap<String, WebSocketSession>> GROUP_SESSION_POOL = new ConcurrentHashMap<>();

   /**
    * 创建组
    *
    * @param key     钥匙
    * @param session 会话
    * @return {@link String}
    */
   public static String create(String key, WebSocketSession session) {
       /*创建组号*/
       String idStr = IdUtil.getSnowflakeNextIdStr();
       /*创建组*/
       ConcurrentHashMap<String, WebSocketSession> group = new ConcurrentHashMap<>();
       /*添加用户*/
       group.put(key, session);
       /*放入组池*/
       GROUP_SESSION_POOL.put(idStr, group);
       /*返回组号*/
       return idStr;

   }

   /**
    * 用户添加进组
    *
    * @param groupId 组id
    * @param key     钥匙
    * @param session 会话
    * @return {@link String}
    */
   public static void add(String groupId, String key, WebSocketSession session) {
       /*创建组号*/
       ConcurrentHashMap<String, WebSocketSession> group = GROUP_SESSION_POOL.get(groupId);
       /*用户添加进组*/
       group.put(key, session);
   }

   /**
    * 解散 组,会返回组号并且通知每一位组员已解散
    *
    * @param groupId 组id
    * @return {@link String}
    */
   public static String remove(String groupId) {
       /*获取要解散的组*/
       ConcurrentHashMap<String, WebSocketSession> group = GROUP_SESSION_POOL.get(groupId);
       /*通知组员已经解散*/
       group.forEach((s, webSocketSession) -> {
           try {
               webSocketSession.sendMessage(new TextMessage("群已解散"));
           } catch (IOException e) {
               throw new RuntimeException(e);
           }
       });
       /*解散组*/
       GROUP_SESSION_POOL.remove(groupId);
       /*返回组号*/
       return groupId;
   }

   /**
    * 用户退组
    *
    * @param groupId 组id
    * @param key     钥匙
    */
   public static void exit(String groupId, String key) {
       /*获取要退出的组*/
       ConcurrentHashMap<String, WebSocketSession> group = GROUP_SESSION_POOL.get(groupId);
       /*用户退出组*/
       group.remove(key);
       /*告知组内成员,用户退组*/
       group.forEach((s, webSocketSession) -> {
           try {
               webSocketSession.sendMessage(new TextMessage("用户" + key + "已经退出组"));
           } catch (IOException e) {
               throw new RuntimeException(e);
           }
       });
   }
}

5.做完上面的还得再加一个webSocket的服务配置启动类

package com.xssq.config;

import com.xssq.Interceptor.WebSocketInterceptor;
import com.xssq.handle.WebSocketHandler;
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;

/**
* web套接字配置
*
* @author xssq
* @version 1.0.0
* @date 2023/10/05
* @wisdom 你可以不会，但你不能不知道
*/
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
   /**
    * web套接字处理程序
    */
   @Autowired
   private WebSocketHandler webSocketHandler;
   /**
    * web套接字拦截器
    */
   @Autowired
   private WebSocketInterceptor webSocketInterceptor;

   /**
    * 注册webSocket字处理程序
    *
    * @param registry 登记处
    */
   @Override
   public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
       registry
               .addHandler(webSocketHandler, "/xssq")
               .addInterceptors(webSocketInterceptor)
               .setAllowedOrigins("*");
   }


}

6.简单说明

在第五步中.addHandler(webSocketHandler, "/xssq")的第二个参数就是你需要连接的路由我这样写的话,连接路径就变成了ws://*******/xssq

后记

做完上面这些,你就会发现配置起来不仅麻烦而且性能还不如TIO简单还有就是没有心跳包,还得自己去配置心跳包,断线机制也得自己来,我现在写的这些都没有用数据库进行保存,如果结合数据库的话就会更加清晰明了用户和组的关系,不过好处也是明显的,就是定制化很强.

但是这些配置的组和管理器在TIO里面都不需要配置了,她都已经实现并且封装好了,我的这个也可以自己去写一个模板到用的时候进行拉取代码也是比较方便的哈

如果我的博客帮助到了您,您可以到我的博客https://blog.csdn.net/weixin_57228276或者微信公众号搜索幸识SQ,在那里可以找到我,里面也有更多的优秀文章