websocket存储session(适合聊天，转发，广播，服务器主动发送消息)

最新推荐文章于 2025-06-20 17:53:11 发布
最新推荐文章于 2025-06-20 17:53:11 发布
阅读量3.6w 收藏 55
点赞数 13
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zero_no1/article/details/79290566
本文介绍了一种使用Spring Boot封装的WebSocket框架来管理WebSocket中的Session信息的方法。通过将Session信息存储到Redis中，实现了用户间的互动与查找功能。文章还详细介绍了如何在连接建立、关闭及消息处理时进行Session的操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

此篇文章主要分享的是websocket存储session信息，在网上经常看到有websocket的例子，此篇文章只是将websocket中的session提取并存储起来，便于用户之间的互动与查找，其实就是解耦合

此实现采用的是springboot的spring封装的websocket框架，原有的tomcat其实也可以完成

首先，spring框架封装的websocket有几种对应

onopen对应afterConnectionEstablished

onclose对应afterConnectionClosed

onMessage对应handleTextMessage

以下是处理消息类

@Component
public class DoubleTeachWSHandler extends TextWebSocketHandler {

    private static final Logger LOG = LoggerFactory
            .getLogger(DoubleTeachWSHandler.class);

    /**
     * 创建连接
     *
     * @param session 用户session
     * @throws Exception
     * @version v1.0
     * @autho 张瑞
     * @date 2017年12月18日 下午3:48:34
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession session) {
        System.out.println("afterConnectionEstablished");
        try {
            //获取用户信息
            SocketUser socketUser = DoubleTeachUserService
                    .getSocketUser(session);
            if (null == socketUser) {
                return;
            }
            //加入redis
            DoubleTeachUserService.addRedis(socketUser);
            //创建房间并加入session
            DoubleTeachSocketRoom.creatRoom(session, socketUser);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

    /**
     * 关闭链接
     *
     * @param session 用户session
     * @param status 状态
     * @throws Exception
     * @version v1.0
     * @autho 张瑞
     * @date 2017年12月18日 下午3:49:04
     */
    @Override
    public void afterConnectionClosed(WebSocketSession session,
            CloseStatus status) {
        System.out.println("afterConnectionClosed");
        try {
            //获取用户信息
            SocketUser socketUser = DoubleTeachUserService
                    .getSocketUser(session);
            if (null == socketUser) {
                return;
            }
            //删除缓存
            DoubleTeachUserService.deleteRedis(socketUser);
            //退出房间
            DoubleTeachSocketRoom.removeUserSession(socketUser);
            //是否删除房间
            DoubleTeachSocketRoom.deleteRoom(socketUser.getRoomID());
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

    /**
     * 处理消息
     *
     * @param session 用户session
     * @param message message消息
     * @throws Exception
     * @version v1.0
     * @autho 张瑞
     * @date 2017年12月18日 下午3:55:18
     */
    @Override
    protected void handleTextMessage(WebSocketSession session,
            TextMessage message) {
        try {
            //获取用户信息
            SocketUser socketUser = DoubleTeachUserService
                    .getSocketUser(session);
            if (null == socketUser) {
                return;
            }
            String str = message.getPayload();
            if (StringUtils.isNull(str)) {
                //空消息不做操作
                return;
            }
            //进行解析
            SocketMessage socketMessage = JSONUtils.parse2Bean(str,
                    SocketMessage.class);
            DoubleTeachSendMsg.mainSendMessage(socketMessage,socketUser);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

}

此处是重点，将session统一存储到此类中，用map存储起来，并自定义key值，value即存储websocket使用的session

@Component
public class DoubleTeachSocketRoom {

    private static final Logger LOG = LoggerFactory
            .getLogger(DoubleTeachSocketRoom.class);

    //整体管理room的map
    private static ConcurrentHashMap<String, SocketRoom> roomMap = new ConcurrentHashMap<String, SocketRoom>(
            10000);

    /**
     * 获取用户session
     *
     * @param socketUser 用户实体
     * @return 用户session
     * @version v1.0
     * @author 张瑞
     * @date 2018年1月24日 上午10:51:11
     */
    public static WebSocketSession getUserSession(SocketUser socketUser) {
        try {
            if (null == socketUser) {
                return null;
            }
            SocketRoom socketRoom = roomMap.get(socketUser.getRoomID());
            if (null == socketRoom) {
                return null;
            }
            WebSocketSession session = socketRoom.getSessionMap()
                    .get(socketUser.getSessionID());
            return session;
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 移除用户session
     *
     * @param socketUser 用户实体
     * @version v1.0
     * @author 张瑞
     * @date 2018年1月24日 上午10:51:40
     */
    public static void removeUserSession(SocketUser socketUser) {
        try {
            if (null == socketUser) {
                return;
            }
            SocketRoom socketRoom = roomMap.get(socketUser.getRoomID());
            if (null == socketRoom) {
                //不需要做操作
                return;
            }
            socketRoom.getSessionMap().remove(socketUser.getSessionID());
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

    /**
     * 获取当前房间用户总体
     *
     * @param roomID 房间ID
     * @return 房间实体
     * @version v1.0
     * @author 张瑞
     * @date 2018年1月24日 上午10:52:24
     */
    public static SocketRoom getSocketRoom(String roomID) {
        try {
            if (StringUtils.isNull(roomID)) {
                return null;
            }
            SocketRoom socketRoom = roomMap.get(roomID);
            return socketRoom;
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 添加用户进入房间并是否创建房间
     *
     * @param session 用户session
     * @param socketUser 用户
     * @version v1.0
     * @author 张瑞
     * @date 2017年12月19日 下午3:44:27
     */
    public static synchronized void creatRoom(WebSocketSession session,
            SocketUser socketUser) {
        SocketRoom socketRoom = roomMap.get(socketUser.getRoomID());
        if (null == socketRoom) {
            socketRoom = new SocketRoom();
            roomMap.put(socketUser.getRoomID(), socketRoom);
        }
        socketRoom.getSessionMap().put(session.getId(), session);
    }

    /**
     * 删除房间
     *
     * @param roomID
     * @version v1.0
     * @author 张瑞
     * @date 2017年12月18日 下午3:54:13
     */
    public static synchronized void deleteRoom(String roomID) {
        SocketRoom socketRoom = roomMap.get(roomID);
        if (null == socketRoom) {
            return;
        }
        if (socketRoom.getSessionMap().size() == 0) {
            roomMap.remove(roomID);
        }
    }

}

聊天室专用的存储表

public class SocketRoom implements Serializable {

    private ConcurrentHashMap<String, WebSocketSession> sessionMap;

    public SocketRoom() {
        sessionMap = new ConcurrentHashMap<String, WebSocketSession>(10000);
    }

    public SocketRoom(int size) {
        sessionMap = new ConcurrentHashMap<String, WebSocketSession>(size);
    }

    public ConcurrentHashMap<String, WebSocketSession> getSessionMap() {
        return sessionMap;
    }

    public void setSessionMap(
            ConcurrentHashMap<String, WebSocketSession> sessionMap) {
        this.sessionMap = sessionMap;
    }

}

用户存储表

public class SocketUser implements Serializable {

    private String token;//用户登录唯一验证
    private String sessionID;//websocketID
    private String roomID;//房间号
    private String liveid;//直播号

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getSessionID() {
        return sessionID;
    }

    public void setSessionID(String sessionID) {
        this.sessionID = sessionID;
    }

    public String getRoomID() {
        return roomID;
    }

    public void setRoomID(String roomID) {
        this.roomID = roomID;
    }

    public String getLiveid() {
        return liveid;
    }

    public void setLiveid(String liveid) {
        this.liveid = liveid;
    }

}

上述步骤主要将处理消息和session分离开，唯一要注意的是移动端的websocket在退出时服务端可能接收不到，一定要注意将session清空。否则session会越寸越大导致内存溢出

附加一个发送消息类

@Component
public class DoubleTeachSendMsg {
    private static final Logger LOG = LoggerFactory
            .getLogger(DoubleTeachSendMsg.class);

    /**
     * 发送消息给用户端的人
     *
     * @param socketMessage 消息
     * @param socketUser 用户
     * @throws IOException
     * @version v1.0
     * @author 张瑞
     * @date 2017年12月19日 下午5:15:56
     */
    private static void sendToClient(SocketMessage socketMessage,
            SocketUser socketUser)
        throws IOException {
        //获取当前端内用户
        List<String> list = Jedis.lrange(
                JedisKeys.userlist,
                socketUser.getLiveid() + ":" + socketUser.getCnum() + ":"
                        + socketMessage.getTo(),
                null, null);
        if (null == list || list.isEmpty()) {
            return;
        }
        //添加返回的json格式的字符串
        String jsonStr = JSONUtils.getJSON(socketMessage);
        //TODO
        LOG.error("to:socketMessage:" + jsonStr);
        for (String key : list) {
            //获取用户
            SocketUser socketUserThis = JSONUtils.parse2Bean(Jedis
                    .get(JedisKeys.USERINFO, key),
                    SocketUser.class);
            if (null == socketUserThis) {
                continue;
            }
            WebSocketSession session = DoubleTeachSocketRoom
                    .getUserSession(socketUserThis);
            if (null != session) {
                Jedis.lpush(
                        JedisKeys.SENDMESSAGE_QUEUE,
                        session.getId(), jsonStr);
                sendMessage(session);
            }
        }
    }

    /**
     * 发送消息(每个用户有自己的发送消息锁)
     *
     * @param session
     * @version v1.0
     * @author 张瑞
     * @date 2018年1月6日 下午1:55:40
     */
    public static void sendMessage(WebSocketSession session) {
        String msg = "";
        try {
            Long lock = Jedis.setnx(
                    JedisKeys.SENDMESSAGE_LOCK,
                    session.getId(), "1");
            if (lock == 1) {
                //循环发送消息
                while (true) {
                    msg = Jedis.rpop(
                            JedisKeysEnum.SENDMESSAGE_QUEUE,
                            session.getId());
                    if (StringUtils.isNull(msg)) {
                        //删除锁
                        Jedis.delete(
                                JedisKeysEnum.SENDMESSAGE_LOCK,
                                session.getId());
                        return;
                    }
                    //判断链接是否存在
                    TextMessage textMessage = new TextMessage(msg);
                    session.sendMessage(textMessage);
    //服务器可能判断isopen不准，简化步骤，不采用，遇到问题直接结束websocket链接
                    /*if (session.isOpen()) {
                        synchronized (session) {
                            session.sendMessage(new TextMessage(msg));
                        }
                    } else {
                        Jedis.delete(
                                JedisKeys.SENDMESSAGE_LOCK,
                                session.getId());
                        Jedis.delete(
                                JedisKeysEnum.SENDMESSAGE_QUEUE,
                                session.getId());
                        //调用结束逻辑
                        session.close();
                    }*/
                }
            }
        } catch (Exception e) {
            //由于客户端断开服务器监听不到，在客户端简历重连机制，发送失败即断开
            //删除锁
            Jedis.delete(JedisKeys.SENDMESSAGE_LOCK,
                    session.getId());
            Jedis.delete(
                    JedisKeys.SENDMESSAGE_QUEUE,
                    session.getId());
            LOG.error("error_msg_is:" + msg);
            LOG.error(e.getMessage(), e);
            try {
                session.close();
            } catch (Exception ex) {
                LOG.error(ex.getMessage(), ex);
            }
        }
    }

}

此为分离websocket的session的实现，有些代码涉及到了业务，进行了删除，理解了整体思路即可。这样，独立出了session信息，在服务器层遇到接口只要能获取存储session的key值，便可发送消息，实现主动发送消息给客户端
使用webSocket简单实现群发消息和指定用户发送消息
05-09
通过调用webSocketSev类的方法,指定用户名,实现指定用户发送消息和群发消息
javaweb + websocket实现客户端
weixin_34029949的博客
03-13 442
最近需要完成一个javaweb项目，但是没有和数据库连接而是通过websocket通讯实现和服务器端数据交互。我搜了好多，网上大部分都是通过页面websocket连接本地服务器或连接异地服务器，但是这些都把连接地址暴露在了外面，不是我想要的。本人希望websocket连接、数据处理等都是在java后端完成的，结合网上的一些参考资料终于实现了此功能。 这里有个比较好的Java后端WebSocket的...
websocket入门到实战（详解websocket，实战聊天室，消息推送，springboot+vue）
最新发布
TinpeaV的博客
06-20 1210
本文详细讲解websocket原理，以及使用websocket结合ruoyi框架进行实战（Springboot+vue+elementui），在项目中使用了websocket的常用接口和技术，详细实现【群发】，【单发】，【消息状态】，【心跳机制】，【断线重连机制】等功能
WebSocket区分不同客户端两种方法（HttpSession和@PathParam）
04-19
WebSocket区分不同客户端两种方法（HttpSession和@PathParam）
分布式集群下WebSocket Session共享解决方案
Java的一只小实习生的博客
07-04 5316
WebSocket Session共享解决方案
Websocket、Session&Cookie、前端基础知识
竹杖芒鞋轻声马
08-31 2437
Websocket、Session&Cookie、前端基础知识
使用Redis解决WebSocket分布式场景下的Session共享问题
境_个人中心
04-11 3894
StandardManager是Tomcat默认使用的，在web应用程序关闭时，对内存中的所有HttpSession对象进行持久化，把他们保存到文件系统中。时，socketsession在第一台服务器线程上，第二次请求，负载到第二台服务器上，需要通过id查找当前用户的session时，是查找不到的。可以看到，我们给8080服务发送的消息，我们订阅的8081和8082 服务可以也可以使用该编号进行消息的推送。在显示项目中遇到了一个问题，需要使用到websocket与小程序建立长链接。使用postman给。
【经验分享】SpringBoot集成WebSocket开发-03 使用WebSocketSession为每个对话存储独立信息
Xcong_Zhu的博客
03-13 1348
如果你希望向所有连接的客户端广播消息，而不仅仅是某个单独的客户端，你需要维护一个所有WebSocket会话的列表。我们可以将用户信息、会话ID等存储在这个属性中，确保每个会话都有独立的数据。这样，每个WebSocket会话就能够独立地存储和访问用户信息、对话ID等数据，同时能够根据不同的会话做出不同的响应。：这个集合存储了所有活跃的WebSocket会话，每个客户端的连接都会被保存到这个集合中。：在WebSocket连接关闭时，移除对应的会话对象，确保集合中只保留当前活跃的会话。
ThinkPHP5+WebSocket+MySQL实现聊天室
04-26
当用户发送消息时，通过WebSocket连接发送到服务器，服务器再广播给所有连接的客户端。 5. **WebSocket消息处理**：服务器接收到消息后，根据消息类型进行处理，如新消息存储到数据库、广播消息给其他用户等。同时...
webChat使用websocket实现网页多人聊天
07-03
WebSocket是一种在客户端和服务器之间建立持久连接的协议，它为实时通信提供了低延迟、高效率的解决方案，尤其适合于需要双向通信的在线应用，如网页聊天室。在本项目"webChat"中，我们将探讨如何利用WebSocket技术...
Spring Boot整合websocket实现群聊，点对点聊天,图片发送，音频发送
10-18
在上面的代码中，我们创建了一个`ChatWebSocketHandler`，它将处理所有与WebSocket相关的操作，如建立连接、接收和发送消息。 ```java import org.springframework.stereotype.Component; import org.spring...
spring websocket获取httpsession
12-18
spring4+ websocket获取httpsession
消息不再转发到服务器配置中,Spring Boot中使用WebSocket总结（二）：向指定用户发送WebSocket消息并处理对方不在线的情况...
weixin_33821888的博客
08-05 1146
在上一篇文章( www.zifangsky.cn/1355.html )中我介绍了在Spring项目中使用WebSocket的几种实现方式。但是，上篇文章中只介绍了服务端采用广播模式给所有客户端发送消息，然而我们有时需要服务端给指定用户的客户端发送消息(比如：发送Web通知、实时打印用户任务的日志、两个用户点对点聊天等)。关于服务端如何给指定用户的客户端发送消息，一般可以通过以下三种方案来实现：方...
websocket 分布式session解决方案
qq_42476097的博客
12-02 1224
websocket分布式session解决方案
redis解决websocket在分布式场景下session共享问题
weixin_45089791的博客
06-18 2829
redis解决websocket在分布式场景下session共享问题 在显示项目中遇到了一个问题，需要使用到websocket与小程序建立长链接。由于项目是负载均衡的，存在项目部署在多台机器上。这样就会存在一个问题，当一次请求负载到第一台服务器时，socketsession在第一台服务器线程上，第二次请求，负载到第二台服务器上，需要通过id查找当前用户的session时，是查找不到的。 可以看到，由于websocket的session并没有实现序列化接口。所以无法将session序列化到redis中。
分布式websocket实时通讯的session共享问题
weixin_42211693的博客
05-15 1682
Bean@Autowired@Bean@Override.collection(collectionName) // 需要监听的集合名// 过滤需要监听的操作类型，可以根据需求指定过滤条件// 不设置时，文档更新时，只会发送变更字段的信息，设置UPDATE_LOOKUP会返回文档的全部信息.build();
vue使用websocket
高山景行，一尘不染
08-01 865
websocket其他特点如下： （1）建立在 TCP 协议之上，服务器端的实现比较容易。 （2）与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。 （3）数据格式比较轻量，性能开销小，通信高效。 （4）可以发送文本，也可以发送二进制数据。 （5）没有同源限制，客户端可以与任意服务器通信...
Websocket Session 共享解决
qq_27276663的博客
03-30 6366
Websocket Session 共享解决（方案一） 既然Websocket Session不能直接序列化然后存储，而且如果用户请求的时候，开始与集群中的A节点创建链接，就算把这个Session 拿到B节点去再给用户Push消息，应该也是不通（没测试）的。 所以我的解决方案采用订阅式队列去触发Websocket 反推的方式来实现看上去是Session共享 的，思路如下图： Websocket Session共享 思路图解释： 模块一：这里没有什么好说明的，因为每一...
Websocket相关问题总结(Session共享，用户多端登录等)
热门推荐
zhuwei_clark的博客
03-10 1万+
我们在使用websocket的时候其实主要面对的问题就是session共享的问题： 不管是基于Spring实现的Websocket的WebsocketSession 还是基于JDK实现的Session 亦或者基于netty实现的ChannelHandlerContext 用图来描述下场景吧： OK，大家看到这个图了，差不多应该明白了Session共享应该怎么处理了。其实原理很简单： ...
java使用websocket后端主动发送消息
03-15
### Java WebSocket 后端主动推送消息实现方式 在Java中，通过WebSocket技术可以让后端主动向客户端发送消息。以下是具体的实现细节： #### 1. 使用 `Session` 对象发送消息 在建立WebSocket连接之后，可以利用 `javax.websocket.Session` 的实例来调用其 `sendMessage()` 方法向前端发送消息[^1]。 ```java import javax.websocket.OnMessage; import javax.websocket.Session; public class MyWebSocketHandler { private Session session; @OnMessage public void onMessage(String message, Session session) throws IOException { this.session = session; // 存储当前会话对象 sendMessageToClient("服务器已接收到您的消息：" + message); } public void sendMessageToClient(String message) throws IOException { if (this.session != null && this.session.isOpen()) { this.session.getBasicRemote().sendText(message); // 发送消息给客户端 } } } ``` 上述代码展示了如何存储会话并使用它来发送消息到前端。 #### 2. Spring Boot 中的 WebSocket 配置与推送逻辑 如果项目基于Spring Boot框架，则可以通过配置WebSocket支持以及定义消息处理类来完成同样的功能[^2]。 ##### （1）启用WebSocket支持 创建一个配置类以注册WebSocket处理器和其他必要组件。 ```java 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; @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(new MyWebSocketHandler(), "/ws").setAllowedOrigins("*"); } } ``` ##### （2）自定义WebSocket处理器 编写用于接收和响应消息的具体业务逻辑。 ```java import org.springframework.stereotype.Component; import org.springframework.web.socket.TextMessage; import org.springframework.web.socket.WebSocketSession; import org.springframework.web.socket.handler.TextWebSocketHandler; @Component public class MyWebSocketHandler extends TextWebSocketHandler { @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { String payload = message.getPayload(); System.out.println("Received Message from Client: " + payload); // 主动推送给客户端的消息 session.sendMessage(new TextMessage("Server received your message: " + payload)); } public void broadcastMessage(String msg, List<WebSocketSession> sessions) throws IOException { for (WebSocketSession session : sessions) { if (session.isOpen()) { session.sendMessage(new TextMessage(msg)); // 广播消息至多个客户端 } } } } ``` 此部分实现了单个客户机之间的双向通讯机制，并提供了广播能力以便于群组通知等功能开发。 #### 应用场景举例 WebSocket非常适合应用于那些需要频繁交互或者即时反馈的服务之中，比如但不限于以下几种情况: - 社交网络中的私信提醒； - 游戏平台上的多人协作模式； - 财经网站上动态刷新的价格变动图表； - 教育软件里的课堂互动环节等等。 --- ###
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值