Spring WebSocket通信应用二[基于Redis实现Ws分布式]

最新推荐文章于 2024-03-20 07:40:15 发布
最新推荐文章于 2024-03-20 07:40:15 发布
阅读量818 收藏 12
点赞数 12
分类专栏： Spring 框架研究 分布式框架 文章标签： spring websocket redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jun55xiu/article/details/135104354
版权

文章目录

概要

Spring WebSocket通信应用-后续
基于Redis实现Spring WebSocket分布式通信。
环境说明：spring-boot-2.5.6、springframework-5.3.12，spring-websocket-5.3.12、spring-data-redis-2.5.6
框架说明：基于 若依框架
采用技术：springboot、websocket、redis发布订阅

需求

实现服务端多节点的情况下，主动推送消息到客户端（即设备1、2、…N）

核心流程说明

1)客户端与服务端建立WebSocket通信，内存集合public final ConcurrentHashMap<String, WebSocketSession> sessionMap = new ConcurrentHashMap<>();存储WebSocketSession sessionId;
redis同步存储,格式<sessionId,sessionId+YYYYMMDDHHMMSS>
2)客户端（即设备1、2、…N，设备的id为设备唯一性属性deviceId）向服务端多节点注册[“/ems/robot/register”]，设备的请求参数有sessionId、deviceId;
redis同步存储设备和WebSocketSession正反双向信息,
格式:[deviceidandsessionid:{sessionId},{deviceId}]、[deviceidandsessionid:{deviceId},{sessionId}];
3)服务端某节点接收请求消息，根据订阅的不同主题向所有服务节点发布消息
4)服务端消息处理器RedisReceiver接收发布消息，开始在每个服务节点处理
5)服务节点根据sessionId匹配内存集合ConcurrentHashMap<String, WebSocketSession> sessionMap ，命中后获取对应WebSocketSession
6)服务节点根据sessionId匹配deviceId，找到设备，并主动推送消息。

websocket配置

参考Spring WebSocket通信应用

Redis发布订阅

提示：redis提供publish/subscribe命令来完成发布、订阅操作,利用此机制，就可以基本实现多节点下的websocket通信

redis缓存配置
具体见RedisCache.java，忽略。

StringRedisTemplate模板配置-RedisConfig.java
配置redis、StringRedisTemplate、增加消息监听器容器绑定主题、消息监听器适配器绑定消息处理器RedisReceiver

package com.ems.mgr.framework.config;
import com.ems.mgr.common.constant.RedisConstants;
import com.ems.mgr.framework.receiver.RedisReceiver;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
/**
 * redis配置
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
    {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * @description:增加redis不同主题的消息监听器容器
     * 添加多个监听不同主题的redis监听器，只需要把消息监听器和相应的消息订阅处理器绑定
     * 该消息监听器通过反射技术调用消息订阅处理器的相关方法进行业务处理
     * @param: [connectionFactory, listenerAdapter]
     * @return: RedisMessageListenerContainer
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        // 1订阅redis发布响应设备消息通知[onMessage]
        container.addMessageListener(listenerAdapter, new PatternTopic(RedisConstants.REDIS_CHANNEL));
        // 2订阅redis发布Websocket断开连接通知[close]
        container.addMessageListener(listenerAdapter,new PatternTopic(RedisConstants.REDIS_CHANNEL_CLOSE));
        // 3订阅redis发布设备消息通知[send]
        container.addMessageListener(listenerAdapter,new PatternTopic(RedisConstants.REDIS_CHANNEL_SEND));
        //4订阅删除Websocket和Redis内存信息消息通知[websocketremove]
        container.addMessageListener(listenerAdapter, new PatternTopic(RedisConstants.WEBSOCKETSESSIONID_REMOVE));
        return container;
    }

    // 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
    @Bean
    MessageListenerAdapter listenerAdapter(RedisReceiver receiver) {
        // 消息监听适配器
        return new MessageListenerAdapter(receiver, "onMessage");
    }

    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory)
    {
        return new StringRedisTemplate(connectionFactory);
    }
}

消息处理器RedisReceiver
服务端接收订阅消息，按不同类型主题分别处理。

package com.ems.mgr.framework.receiver;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ems.mgr.common.constant.RedisConstants;
import com.ems.mgr.websocket.commons.JacksonUtil;
import com.ems.mgr.websocket.handler.MerakSocketHandler;
import com.ems.mgr.websocket.model.MessageBodyBean;
import com.ems.mgr.websocket.model.WsResponse;
import com.fasterxml.jackson.core.type.TypeReference;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.TextMessage;

import javax.annotation.Resource;

/**
 * @author harry
 * @version 1.0
 * @description: 消息监听对象，接收订阅消息
 */
@Component
public class RedisReceiver implements MessageListener {
    Logger log = LoggerFactory.getLogger(this.getClass());

    @Resource
    private MerakSocketHandler webSocketServer;

    /**
     * 处理接收到的订阅消息
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
        // 获取订阅的频道名称
        String channel = new String(message.getChannel());
        String msg = "";
        try {
            // 注意与发布消息编码一致，否则会乱码
            msg = new String(message.getBody(), RedisConstants.UTF8);
            if (StringUtils.isNotEmpty(msg)) {
                if (channel.endsWith(RedisConstants.REDIS_CHANNEL_CLOSE)) {
                    log.info("订阅redis发布Websocket断开连接通知[close],消息体:" + msg);
                    // websocket连接关闭的消息-调用关闭接口
                    webSocketServer.closeMessageBySessionId(msg);
                } else if (channel.endsWith(RedisConstants.REDIS_CHANNEL_SEND)) {
                    MessageBodyBean wsParam = JacksonUtil.json2Bean(msg, new TypeReference<MessageBodyBean>() {
                    });
                    log.info("订阅redis发布设备消息通知[send],消息体:" + JacksonUtil.bean2Json(wsParam));
                    // 向客户端推向消息的接口
                    String sessionId = wsParam.getSessionId();
                    WsResponse<MessageBodyBean> response = new WsResponse<>();
                    response.setResult(wsParam);
                    webSocketServer.sendMessageBySessionId(sessionId, new TextMessage(JacksonUtil.bean2Json(response)));
                } else if (channel.endsWith(RedisConstants.REDIS_CHANNEL)) {
                    log.info("订阅redis发布响应设备消息通知[onMessage],消息体: ........");
                    MessageBodyBean wsParam = JacksonUtil.json2Bean(msg, new TypeReference<MessageBodyBean>() {
                    });
                    // 向客户端推向消息的接口
                    String sessionId = wsParam.getSessionId();
                    WsResponse<MessageBodyBean> response = new WsResponse<>();
                    response.setResult(wsParam);
                    webSocketServer.sendMessageBySessionId(sessionId, new TextMessage(JacksonUtil.bean2Json(response)));
                }else if (channel.endsWith(RedisConstants.WEBSOCKETSESSIONID_REMOVE)) {
                    //删除Websocket内存集合信息
                    log.info("订阅消息-websocketremove,删除Websocket和Redis内存信息消息通知[websocketremove],消息体:" + msg);
                    JSONObject jsonObject = JSON.parseObject(msg);
                    webSocketServer.removeWebsocketBySessionId(jsonObject.get("sessionId").toString(),jsonObject.get("deviceId").toString());
                }
            } else {
                log.info("消息内容为空，不处理。");
            }
        } catch (Exception e) {
            log.error("处理消息异常：" + e.getMessage());
        }
    }
}

典型场景：redis发布设备响应消息通知
流程：设备（客户端）向某个服务节点（如node2）发送消息------服务节点基于redis特性发布设备响应消息通知------消息处理器RedisReceiver接收订阅消息、处理【所有服务节点】-----------某个服务节点（如node1）根据sessionId匹配内存集合ConcurrentHashMap<String, WebSocketSession> sessionMap ，命中后获取对应WebSocketSession-----------服务节点node1向设备（客户端）响应消息

某个服务节点（如node2）接收设备（客户端）消息：

@Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String sessionId = session.getId();
        logger.info("handleTextMessage from robot...,sessionId:" + sessionId);
        String msg = message.getPayload();
        logger.info("handleTextMessage msg:" + msg);
        MessageBodyBean wsParam = JacksonUtil.json2Bean(msg, new TypeReference<MessageBodyBean>() {
        });
        if ("signaling".equals(wsParam.getMessageType()) && "heartbeat".equals(wsParam.getMessageContext())) {
            logger.info("handleTextMessage-Robot心跳监测响应");
            webSocketSessionHandler.subtractHeartbeatMonitorMap(sessionId);
        } else {
            logger.info("handleTextMessage-普通响应");
//            WsResponse<MessageBodyBean> response = new WsResponse<>();
            MessageBodyBean messageBodyBean = new MessageBodyBean();
            messageBodyBean.setSessionId(sessionId);
            messageBodyBean.setMessageType("signaling");
            messageBodyBean.setMessageContext("response");
//            response.setResult(messageBodyBean);
//            ConcurrentWebSocketSessionDecorator sessionDecorator = (ConcurrentWebSocketSessionDecorator) webSocketSessionHandler.getSession(sessionId);
//            sendMessageToUser(sessionDecorator, new TextMessage(JacksonUtil.bean2Json(response)));
            publishSendMessage(messageBodyBean);
        }
        logger.info("handleTextMessage end...");
    }

服务节点基于redis特性RedisTemplate.convertAndSend(String channel, Object message) API方法，发布设备响应消息通知

/**
     * @description:分布式-使用redis发布设备响应消息通知
     */
    public void publishSendMessage(MessageBodyBean wsParam) {
        try {
            logger.info("publishSendMessage:redis发布响设备应消息通知,sessionId:" + wsParam.getSessionId());
            StringRedisTemplate template = SpringUtils.getBean(StringRedisTemplate.class);
            template.convertAndSend(RedisConstants.REDIS_CHANNEL, JSON.toJSONString(wsParam));
            logger.info("publishSendMessage:redis发布响应设备消息通知,sessionId:" + wsParam.getSessionId());
        } catch (Exception e) {
            logger.error("publishSendMessage:redis发布响应设备消息通知异常,sessionId:" + wsParam.getSessionId() + ",error:" + e.getMessage());
        }
    }

消息处理器RedisReceiver接收订阅消息、处理【所有服务节点】

/**
     * 处理接收到的订阅消息
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
        // 获取订阅的频道名称
        String channel = new String(message.getChannel());
        String msg = "";
        try {
            // 注意与发布消息编码一致，否则会乱码
            msg = new String(message.getBody(), RedisConstants.UTF8);
            if (StringUtils.isNotEmpty(msg)) {
                if (channel.endsWith(RedisConstants.REDIS_CHANNEL_CLOSE)) {
                   。。。
                } else if (channel.endsWith(RedisConstants.REDIS_CHANNEL_SEND)) {
                   。。。
                } else if (channel.endsWith(RedisConstants.REDIS_CHANNEL)) {
                    log.info("订阅redis发布响应设备消息通知[onMessage],消息体: ........");
                    MessageBodyBean wsParam = JacksonUtil.json2Bean(msg, new TypeReference<MessageBodyBean>() {
                    });
                    // 向客户端推向消息的接口
                    String sessionId = wsParam.getSessionId();
                    WsResponse<MessageBodyBean> response = new WsResponse<>();
                    response.setResult(wsParam);
                    webSocketServer.sendMessageBySessionId(sessionId, new TextMessage(JacksonUtil.bean2Json(response)));
                }else if (channel.endsWith(RedisConstants.WEBSOCKETSESSIONID_REMOVE)) {
                   。。。
                }
            } else {
                log.info("消息内容为空，不处理。");
            }
        } catch (Exception e) {
            log.error("处理消息异常：" + e.getMessage());
        }
    }

某个服务节点（如node1）根据sessionId匹配内存集合ConcurrentHashMap<String, WebSocketSession> sessionMap ，命中后获取对应WebSocketSession

 /**
     * @description: 外部接口通过指定的sessionId向该设备推送消息
     */
    public void sendMessageBySessionId(String sessionId, TextMessage message) {
        logger.info("sendMessageBySessionId start,sessionId:" + sessionId);
        try {
            ConcurrentWebSocketSessionDecorator sessionDecorator = (ConcurrentWebSocketSessionDecorator) webSocketSessionHandler.getSession(sessionId);
            if (null != sessionDecorator) {
                if (sessionDecorator.isOpen()) {
                    sessionDecorator.sendMessage(message);
                    logger.info("redis发布设备消息通知:匹配指定设备,sessionId=" + sessionId);
                } else {
                    logger.info("redis发布设备消息通知:匹配指定设备已经离线,sessionId=" + sessionId);
                }
            } else {
                logger.info("redis发布设备消息通知:其它指定设备,sessionId=" + sessionId);
            }
            logger.info("sendMessageBySessionId end,sessionId:" + sessionId);
        } catch (IOException e) {
            logger.error("sendMessageBySessionId error,sessionId:" + sessionId + ",error:" + e.getMessage());
        }
    }

服务节点node1向设备（客户端）响应消息

sessionDecorator.sendMessage(message);

源代码

源代码下载

陈鋆
关注
  • 12
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis实现WebSocket分布式通信
01-04
采用技术：springboot、websocket、redis发布订阅; 基于Redis实现Spring WebSocket分布式通信。 环境说明：spring-boot-2.5.6、springframework-5.3.12，spring-websocket-5.3.12、spring-data-redis-2.5.6、JDK 8 实现服务端多节点的情况下，主动推送消息到客户端（即设备1、2、......N）
Spring WebSocket通信应用实例demo
12-14
Spring WebSocket通信应用实例demo、双向通信、WebSocket、心跳监测
SpringBoot+Redis实现分布式WebSocket
★【World Of Moshow 郑锴】★
03-19 1516
在分布式系统架构中实现WebSocket的通信机制，它允许在不同的服务器节点之间共享和同步WebSocket会话状态，从而实现跨多个服务器的实时消息传递。会话共享：在分布式系统中，用户的WebSocket连接可能与不同的服务器建立，这就要求系统能够在不同服务器间共享WebSocket会话信息，以便消息能够被正确地传递到所有相关的客户端。负载均衡：使用负载均衡可以提高系统的可用性和伸缩性。
java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统.zip
06-24
Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。 Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天
解决springboot整合websocket、redis、openfeign，redisTemplate，openfeign的类无法注入的问题
weixin_44808225的博客
11-07 501
在部分业务中，我们需要使用长连接，我们可以使用http长连接或者websocket，在springboot作为后端的框架中， 可以借用的技术是（netty，websocket）
实时消息推送（一）WebSocket+Redis
Diligent的博客
11-20 573
使用websocket和redis实现实时消息推送
【SpringBoot整合Redis+WebSoket】
Small ink的博客
12-26 1302
socket属于长连接，其session只会保存在一台服务器上，其他负载及其不会持有这个session，此时，我们需要使用redis的发布订阅来实现，session的共享。因为现在很多项目都是前后分离的，所以前端走后端基本都是通过Nginx或公共网关来统一转发请求，WebSoket使用的是长连接默认的Nginx是不支持长连接的所以需要配置，请参考。sendMessage：发生消息的方法（自己封装的，并不限制，按要求扩展），因为我们使用的是redis的发布订阅方式所以我们使用的是Redis的订阅来发送消息。
springboot+websocket+redis
凉白开不加冰
06-10 7658
介绍：通过websocket+redis做一个简单的客服聊天系统 流程图： 说明： 客服管理人员登录后台，点击客服界面的时候，创建websocket客户端，等待接受用户消息 用户从页面点击客服服务的时候，创建websocket客户端，这时候将消息发送给客服 客服接收到用户消息，回复消息给用户 用户发送消息以及客服回复消息都通过API接口调用，然后转发给对应的websocket客户端 第一步：...
Websocket只看这一篇就够了 SpringBoot+Websocket+Redis 实现websocket集群
无知无畏的博客
08-27 3457
关于websocket做一次全面的总结。 实现的难点在什么地方？ WebSocketSession 是不能放在redis中共享的。所以共享Session的方法是不可行的。 WebSocket是长链接所以只能通过保持连接的服务器通知对应的客户端。一旦需要发送消息的服务器和保持连接的服务器不是同一台服务器时就有问题了。 实现WebSocket集群的2种方式 用redis的订阅/推送功能实现的。（推荐） 用redis存客户端连接对应的服务器的IP+端口，再用http去调用对应服务器的接口。 用redi.
Springboot集成redis和mybatis-plus及websocket异常框架代码封装
专注技术交流、咨询
11-08 467
Springboot集成redis和mybatis-plus及websocket异常框架代码封装，日志使用p6spy，带参数打印SQL，本博文主要分五大块讲解，分别为websocket的使用、mybatis-plus的使用、redis的使用、异常信息怎么使用、日志打印（重点是带参数打印sql语句，方便开发调式）
使用redis做websocket分布式消息推送服务
chen417980762的博客
11-25 4514
redis、websocket实现同一账户多点登录、websocket服务多节点部署推送方案。 简单架构图 用户A两个地方登录连接到两个websocketServer节点，用户B连接到2节点。消息生产者发布消息的时候应为map格式receive=userid，msg="msg...."，将消息推送给对应的userid。 1.该项目为springboot项目，先引入w......
springws:基于SpringMVC实现的WebSocket工程实例
05-10
Spring-ws基于SpringMVC实现的支持SockJS的WebSocket工程实例说明本项目为maven项目，使用SpringMVC实现，用于展示如果使用 SockJS。项目启动后直接打开对应的端口在首页就可以看到展示的功能。后端在"/echo"上添加...
基于Spring Boot+WebSocket+Redis开发的分布式即时通讯群聊系统源码+项目使用说明.zip
06-13
基于Spring Boot+WebSocket+Redis开发的分布式即时通讯群聊系统源码+项目使用说明.zip 该项目是个人毕设项目源码，评分达到95分，都经过严格调试，确保可以运行！放心下载使用。 该项目资源主要针对计算机、自动化等...
Springboot 整合 WebSocket ，使用STOMP协议+Redis 解决负载场景问题
最新发布
m0_62673499的博客
03-20 631
Description EnableWebSocketMessageBroker-注解开启STOMP协议来传输基于代理的消息，此时控制器支持使用@MessageMapping。System.out.println(“步骤1.监听到需要进行负载转发的消息：” + message.toString());
Spring4.3.7整合Websocket+Redis实现分布式消息推送
HuaDi
08-11 692
简单的消息推送新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 你好！ 这是你第一次使用 Markdown编辑...
【十五】springboot整合WebSocket实现聊天室
热门推荐
weixin_56995925的博客
10-08 1万+
springboot整合WebSocket实现聊天室
Springboot+websocket+Stomp使用Redis实现分布式消息推送
左岸天涯--博客
10-24 2308
引言 由于新需求，需要实现多语言下实现websocket消息通讯推送，本来打算引入高级消息队列协议的，但体量没那么大，所以选型时选择了通过redis的队列来实现。 实现步骤 pom引入 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional&
SpringBoot 实现WebSocket页面消息推送及Redis 发布订阅和队列功能
纸上得来终觉浅，绝知此事要躬行
05-30 9560
项目简介：采用SpringBoot开发项目实现大屏数据展示功能，轻量级处理额外需求业务。基于Redis服务发布订阅功能，实现系统有新数据的时候主动推送数据到大屏的WebSocket监听页面进行展示。队列的消费需要提供接口这个方式不够友好，发布订阅只需要在另一个服务器上同样部署一个springboot开发的应用并订阅相同的主题即可（队列功能适合同一应用环境下，引用项目打包后的jar包进行开发即可）。...
爬山的蜗牛旅程：十一、springboot +websocket+redis 实现分布式在线聊天
m0_37781593的博客
09-26 933
学习springboot的旅程，就像蜗牛爬山，一点点的往上爬，一点点的欣赏旅途的风景 小猿公司的系统又要升级了，现在要实现在线聊天。这个怎么搞呢？ 特别是在分布式系统下，怎么搞分布式在线聊天呢？ 第一点：客户端与服务端通过websocket技术创建连接（这样服务端才能向客户端推送数据） 第二点：服务端之间的通信，请看redis的订阅和发布 第三点：创建聊天测试页面 springboot 实...
springboot+websocket+netty+redis 实现即时通讯
12-24
Spring Boot是一个基于Spring框架的快速开发、简化配置的工具，它能够快速搭建和部署各种应用程序。WebSocket是一种在单个 TCP 连接上进行全双工通信的协议，它能够实现客户端和服务器之间的实时通讯。Netty是一款高性能的异步事件驱动的网络应用框架，能够实现快速的数据传输。Redis是一种高性能的键值对存储数据库，能够实现快速的数据缓存和持久化。通过结合Spring Boot、WebSocket、Netty和Redis，可以实现基于即时通讯的应用程序。 首先，通过Spring Boot框架搭建应用程序的后端服务，包括用户认证、消息管理等功能。然后，利用WebSocket实现客户端和服务器之间的实时通讯，包括消息的发送和接收。接着，利用Netty框架实现底层网络通讯，确保数据的快速传输和高性能。最后，利用Redis实现消息的缓存和持久化，确保消息的可靠性和一致性。 整个过程中，Spring Boot负责整个应用程序的搭建和配置，WebSocket负责实时通讯的实现，Netty负责底层网络通讯的实现，Redis负责消息的缓存和持久化。通过这些组件的组合，可以实现一个基于Spring Boot、WebSocket、Netty和Redis的即时通讯应用程序，实现了快速、高性能和可靠的实时通讯功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值