目录
7、RedisReceiver（消息监听对象，接收订阅消息进行处理）
10、通过RocketMq实现websocket的session共享
由于项目是集群部署，需要实现对websocket的session共享，可websocket的session无法序列化，不能存放到Redis当中，因此我们可以把websocket的session存放在服务器的map上，通过Redis的广播把消息发送到指定的频道上，每个服务器节点都订阅该频道，从而消息一经发布都能收到再从map中获取session完成消息的推送
1、引入所需依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>2、所需常量类（根据需求自定义）
package com.zzw.redops.utils;
/**
* @description: 常量类
* @dateTime: 2021/6/17 16:21
*/
public class Constants {
/**
* UTF-8 字符集
*/
public static final String UTF8 = "UTF-8";
/** redis 订阅消息通道标识*/
public final static String REDIS_CHANNEL = "onMessage";
public final static String REDIS_CHANNEL_CLOSE="close";
public final static String REDIS_CHANNEL_SEND="send";
/** 消息体的key*/
public final static String REDIS_MESSAGE_KEY = "KEY";
/** 消息体的值*/
public final static String REDIS_MESSAGE_VALUE = "VALUE";
}
3、Redis配置文件
package com.zzw.redops.utils;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@EnableCaching
public class RedisConfig {
@Bean
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<String,Object>();
redisTemplate.setConnectionFactory(factory);
// json序列化
Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jsonRedisSerializer.setObjectMapper(om);
// String序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// 设置redis各种数据类型的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setHashKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(jsonRedisSerializer);
redisTemplate.setHashValueSerializer(jsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
// redis消息监听器容器 可以添加多个监听不同话题的redis监听器，只需要把消息监听器和相应的消息订阅处理器绑定
// 该消息监听器通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
// 可以添加多个messageListener，配置不同的交换机
container.addMessageListener(listenerAdapter, new PatternTopic(Constants.REDIS_CHANNEL));
container.addMessageListener(listenerAdapter,new PatternTopic(Constants.REDIS_CHANNEL_CLOSE));
container.addMessageListener(listenerAdapter,new PatternTopic(Constants.REDIS_CHANNEL_SEND));
return container;
}
// 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
@Bean
MessageListenerAdapter listenerAdapter(RedisReceiver receiver) {
// 消息监听适配器
return new MessageListenerAdapter(receiver, "onMessage");
}
}
4、websocket配置文件
package com.zzw.redops.utils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
/**
* @Date:2021/5/26 19:09
*/
/**
* 开启WebSocket支持
*/
@Configuration
public class WebSocketConfig {
/**
* ServerEndpointExporter 作用
* 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
* @return
*/
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}5、WebSocketSession实体类用来存放session信息
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class WebSocketSession {
/**
* 用户ID
*/
private String userId;
/**
* webSocket会话
*/
private Session session;
/**
* 创建时间
*/
private Date createTime;
}6、websocket服务类
package com.zzw.redops.utils;
import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zzw.redops.constant.Constants;
import com.zzw.redops.constant.RocketConstants;
import com.zzw.redops.factory.WebSocketFactory;
import com.zzw.redops.handle.AbstractWebSocketHandle;
import com.zzw.redops.service.RocketApiService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
/**
* @Date:2021/5/26 19:12
*/
@Slf4j
@Component
@ServerEndpoint("/ws/{userId}")
public class WebSocketServer {
/**
* concurrent 包的线程安全Set，用来存放每个客户端对应的 myWebSocket对象
* 根据userId来获取对应的 WebSocket
*/
private static ConcurrentHashMap<String, WebSocketSession> webSocketMap = new ConcurrentHashMap<>();
private String userId;
/**
* 注入service
*/
RocketApiService rocketApiService = SpringUtils.getBean(RocketApiService.class);
StringRedisTemplate stringRedisTemplate = SpringUtils.getBean(StringRedisTemplate.class);
WebSocketFactory webSocketFactory = SpringUtils.getBean(WebSocketFactory.class);
/**
* 处理消息
*
* @param userId 用户ID
* @param url 地址
* @param sessionId 会话ID
* @param jsonObject json对象
*/
public void doMessage(JSONObject jsonObject, String userId, String url) throws Exception {
WebSocketSession webSocketSession = webSocketMap.get(userId);
if (Objects.isNull(webSocketSession)) {
log.info("此请求不处理：{}", url);
return;
}
AbstractWebSocketHandle webSocketHandle = webSocketFactory.create(url);
if (Objects.isNull(webSocketHandle)) {
log.error("doMessage webSocketHandle is null url={}", url);
return;
}
webSocketHandle.doMessage(jsonObject, userId, url);
}
/**
* 连接建立成功调用的方法
*
* @param session
* @param userId
*/
@OnOpen
public void onOpen(Session session, @PathParam("userId") String userId) {
try {
this.userId = userId;
WebSocketSession socketSession = WebSocketSession.builder()
.userId(userId)
.session(session)
.createTime(new Date())
.build();
webSocketMap.put(userId, socketSession);
// 广播删除相同用户的会话
Map<String, String> map = new HashMap<>();
map.put("userId", userId);
map.put("createTime", GetDateUtils.smfDate(socketSession.getCreateTime()));
map.put("flag", "delete");
stringRedisTemplate.convertAndSend(Constants.REDIS_CHANNEL_SEND, JSONObject.toJSONString(map));
log.info("有新的窗口开始监听：{}", userId);
} catch (Exception e) {
log.error("onOpen Exception", e);
}
}
/**
* 关闭连接
*/
@OnClose
public void onClose(Session session) {
log.info("关闭时参数session：{} 用户ID：{}", session, userId);
Map<String, String> map = new HashMap<>();
map.put(Constants.REDIS_MESSAGE_KEY, userId);
// 广播消息
stringRedisTemplate.convertAndSend(Constants.REDIS_CHANNEL_CLOSE, JSON.toJSONString(map));
}
// 关闭
public void close(String userId) {
try {
// 删除会话
webSocketMap.remove(userId);
log.info("有一连接关闭，用户ID：{}", userId);
} catch (Exception e) {
log.error("websocket断开连接 exception:", e);
}
}
/**
* 收到客户端消息后调用的方法
*
* @param message 客户端发送过来的消息
* @param session
*/
@OnMessage
public void onMessage(String message, Session session) throws IOException {
log.info("收到来自窗口" + userId + "的信息：" + message);
sendMessageByRedis(message, userId);
}
// Redis广播消息
public void sendMessageByRedis(String message, String userId) {
String newMessge = null;
try {
newMessge = new String(message.getBytes(Constants.UTF8), Constants.UTF8);
} catch (UnsupportedEncodingException e) {
log.error("sendMessageByRedis exception:", e);
}
Map<String, String> map = new HashMap<String, String>();
map.put(Constants.REDIS_MESSAGE_KEY, userId);
map.put(Constants.REDIS_MESSAGE_VALUE, newMessge);
// 广播
stringRedisTemplate.convertAndSend(Constants.REDIS_CHANNEL, JSON.toJSONString(map));
}
@OnError
public void onError(Session session, Throwable error) {
if (Objects.isNull(webSocketMap.get(session.getId()))) return;
log.error("用户错误：" + webSocketMap.get(session.getId()).getUserId() + "，原因：" + error.getMessage());
}
// 广播消息
public void sendMessage(String userId, String message) {
Map<String, String> map = new HashMap<>();
map.put("userId", userId);
map.put("message", message);
map.put("flag", "send");
stringRedisTemplate.convertAndSend(Constants.REDIS_CHANNEL_SEND, JSONObject.toJSONString(map));
}
public void sendToFront(String userId, String message) throws IOException {
if (StringUtils.isBlank(userId)) {
log.info("向前端推送消息时用户ID为空：message：{} userId：{}",message,userId);
return;
}
// 根据用户ID获取session
List<WebSocketSession> list = getWebSocketSession(userId);
if (CollectionUtil.isNotEmpty(list)) {
for (WebSocketSession item : list) {
sendMessage(item, message);
}
}else {
log.info("向前端推送消息获取session时为空：userId：{} session：{}",userId,list);
}
}
public static void sendMessage(WebSocketSession wssession, String message) throws IOException {
if (Objects.isNull(wssession)) {
log.info("向前端推送消息时session为空：message：{} session：{}",message,wssession);
return;
}
try {
synchronized (wssession) {
wssession.getSession().getBasicRemote().sendText(message);
}
} catch (Exception e) {
log.error("sendText exception:",e);
}
}
// 根据用户ID获取session
public List<WebSocketSession> getWebSocketSession(String userId) {
if (StringUtils.isBlank(userId)) {
return null;
}
List<WebSocketSession> result = new ArrayList<>();
for (String key : webSocketMap.keySet()) {
if (userId.equals(key)) {
result.add(webSocketMap.get(key));
}
}
// 如果一个用户ID对应多个会话，取最新的会话返回
if (result.size() > 1) {
// 按照创建时间倒序排序
List<WebSocketSession> collect = result.stream().sorted(Comparator.comparing(WebSocketSession::getCreateTime).reversed()).limit(1).collect(Collectors.toList());
log.info("会话重复时返回最新会话：{}", collect);
return collect;
}
return result;
}
public void sendInfo(String message, List<String> channelsMembersId) {
// 向房间内用户推送数据
for (String item : channelsMembersId) {
sendMessage(item, message);
}
}
public void newDeleteSeamSession(String userId, String createTime) {
if (StringUtils.isBlank(userId) || StringUtils.isBlank(createTime)) {
return;
}
log.info("删除前map大小：{}", webSocketMap.size());
Iterator<String> iterator = webSocketMap.keySet().iterator();
while (iterator.hasNext()) {
String item = iterator.next();
if (userId.equals(item)) {
WebSocketSession webSocketSession = webSocketMap.get(item);
if (!createTime.equals(GetDateUtils.smfDate(webSocketSession.getCreateTime()))) {
iterator.remove();
}
}
}
log.info("删除后map大小：{}", webSocketMap.size());
}
}在onMessage、onClose、sendMessage方法中将消息广播到Redis对应的频道中，监听到消息后进行相应的业务处理再把结果推送给客户端
7、RedisReceiver（消息监听对象，接收订阅消息进行处理）
package com.zzw.redops.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zzw.redops.vo.jurisdiction.ResultBack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.stereotype.Component;
import org.apache.commons.lang3.StringUtils;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
/**
* 消息监听对象，接收订阅消息
*/
@Component
public class RedisReceiver implements MessageListener {
Logger log = LoggerFactory.getLogger(this.getClass());
@Resource
private WebSocketServer webSocketServer;
/**
* 处理接收到的订阅消息
*/
@Override
public void onMessage(Message message, byte[] pattern) {
// 获取订阅的频道名称
String channel = new String(message.getChannel());
String msg = "";
try {
// 注意与发布消息编码一致，否则会乱码
msg = new String(message.getBody(), Constants.UTF8);
if (StringUtils.isNotEmpty(msg)){
if (channel.endsWith(Constants.REDIS_CHANNEL_CLOSE)){
// websocket连接关闭的消息
JSONObject json = JSON.parseObject(msg);
// 获取用户ID
String userId = json.getString("userId");
// 获取sessionID
String sessionId = json.getString(Constants.REDIS_MESSAGE_KEY);
// 调用关闭接口
webSocketServer.close(sessionId,userId);
}else if (channel.endsWith(Constants.REDIS_CHANNEL_SEND)){
// 向客户端推向消息的接口
JSONObject json = JSONObject.parseObject(msg);
if (json.getString("flag") != null){
if ("send".equals(json.getString("flag"))){
webSocketServer.sendToFront(json.getString("userId"),json.getString("message"));
}
}else {
log.info("其它消息，不予处理");
}
}
}else{
log.info("消息内容为空，不处理。");
}
} catch (Exception e) {
log.error("处理消息异常："+e.toString());
e.printStackTrace();
}
}
}8、小结
省去了业务逻辑的代码，这是根据需求而异的，大家自行发挥即可；最后说一下我对这个模式的理解，刚开始做的时候也是半知半解，请教了多次公司的大佬才完成，对于为什么这样做我是这么想的：假如我们部署了A、B两台服务，有张三和李四两个用户在一个聊天室C中，张三请求到A服务上，他的信息保存在A上，李四请求到B服务信息保存在B上，如果不做session的共享，这时张三发了一条信息请求到B服务上，处理完之后需要向聊天室C中推送消息，B上面没有张三的session信息所以就无法推送成功，也就不能实现消息的实时传输；当我们通过Redis广播之后，A、B两台服务都会收到信息进行处理，在各自的map中获取张三的session信息，拿到之后就向聊天室中推送消息，拿不到就说明张三的信息不在此服务上不予处理；我们可以在业务接口中先获取session信息，拿不到就不处理，这样可以节省资源
还有一种方式是我们可以在websocket开启和关闭的时候广播到所有服务器上，这时每台服务器都有相同的session信息，而onMessage和推送消息时不进行广播消费，这样它无论请求到哪台服务器上都能进行处理
9、Websocket中的doMessage实现
https://blog.csdn.net/mlwsmqq/article/details/12183714710、通过RocketMq实现websocket的session共享
有什么错误的地方，欢迎各位指正！
转载请注明出处！！！
1318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
