关于分布式websocket踩的坑及解决方案

最新推荐文章于 2025-04-24 11:00:21 发布

扫地僧、

最新推荐文章于 2025-04-24 11:00:21 发布

阅读量2.1k

点赞数 3

分类专栏：分布式websocket解决方案文章标签： java

本文链接：https://blog.csdn.net/weixin_50063960/article/details/117918478

版权

分布式websocket解决方案专栏收录该内容

1 篇文章

订阅专栏

关于websocket知识点

首先了解下websocket与http协议

1、WebSocket是HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议，使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

它是为了解决客户端发起多个http请求到服务器资源浏览器必须要经过长时间的轮训问题而生的，他实现了多路复用、全双工通信。在webSocket协议下客服端和浏览器可以同时发送信息。

2、HTTP的协议是应用层的协议，他是基于TCP协议的，HTTP协议建立连接必须有三次握手才能发送消息（这里就不在赘述具体是怎么实现的）。即每一个request对应一个response。客户端与服务器端通信，必须由客户端发起服务器端返回结果。客户端是主动的，服务器端是被动的。

HTTP的长链接和WebSocket持久连接的区别：

HTTP1.1 的连接默认使用长连接（persistent connection），即在一定的期限内保持链接，客户端会需要在短时间内向服务端请求大量的资源，保持TCP连接不断开。客户端与服务器通信，必须要有客户端发起然后服务器返回结果。客户端是主动的，服务器是被动的。在一个TCP连接上可以传输多个Request/Response消息对，所以本质上还是Request/Response消息对，仍然会造成资源的浪费、实时性不强等问题。

1、如果不是持续连接，即短连接，那么每个资源都要建立一个新的连接，HTTP底层使用的是TCP，那么每次都要使用三次握手建立TCP连接，即每一个request对应一个response，将造成极大的资源浪费。

长轮询，即客户端发送一个超时时间很长的Request，服务器hold住这个连接，在有新数据到达时返回Response

2、Websocket的持久连接只需建立一次Request/Response消息对，之后都是TCP连接，避免了需要多次建立Request/Response消息对而产生的冗余头部信息。

Websocket只需要一次HTTP握手，所以说整个通讯过程是建立在一次连接/状态中，而且websocket可以实现服务端主动联系客户端，这是http做不到的

我们开始回到正题

1 添加pom依赖

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

2 自定义service
自定义WebSocketServer，使用底层的websocket方法，提供对应的onOpen、onClose、onMessage、onError方法
1、添加配置类

import org.springframework.context.annotation.Configuration;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.server.HandshakeInterceptor;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

import javax.servlet.http.HttpSession;
import java.util.Map;

@Configuration
// 注解开启STOMP协议来传输基于代理的消息，此时控制器支持使用@MessageMapping
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    /**
     * 扫描并注册带有@ServerEndpoint注解的所有服务端
     * @return
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        /**
         * 订阅来自"/topic"和"/user"的消息，
         * 设置一个或者多个代理前缀，在 Controller 类中的方法里面发生的消息，会首先转发到代理从而发送到对应广播或者队列中。
         * /topic 单聊
         * /all 群聊
         */
        config.enableSimpleBroker("/topic", "/all");

        /**
         * 客户端发送过来的消息，需要以"/app"为前缀，再经过Broker转发给响应的Controller
         * 配置客户端发送请求消息的一个或多个前缀，该前缀会筛选消息目标转发到 Controller 类中注解对应的方法里
         */
        config.setApplicationDestinationPrefixes("/app");

        /**
         * 服务端通知特定用户客户端的前缀，可以不设置，默认为user
         */
//        config.setUserDestinationPrefix("/user");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {

        /**
         * 路径"/websocket"被注册为STOMP端点，对外暴露，客户端通过该路径接入WebSocket服务
         * 设置允许跨域，设置为"*"则为允许全部域名
         */
        registry.addEndpoint("/websocket")
                .setAllowedOrigins("*")
                .addInterceptors(new HttpHandshakeInterceptor())
                .withSockJS();
    }

    class HttpHandshakeInterceptor implements HandshakeInterceptor {
        /**
         * 握手前拦截，从 HTTP 中参数传入 WebSocket Attributes 方便后续取出相关参数
         *
         * @param request    请求对象
         * @param response   响应对象
         * @param wsHandler  WebSocket 处理器
         * @param attributes 从 HTTP 握手到与 WebSocket 会话关联的属性
         * @return 如果返回 true 则继续握手，返回 false 则终止握手
         */
        @Override
        public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                                       Map<String, Object> attributes) throws Exception {
            // 将 request 对象转换为 ServletServerHttpRequest 对象
            ServletServerHttpRequest serverRequest = (ServletServerHttpRequest) request;
            // 获取 HTTP Session 对象
//            HttpSession session = serverRequest.getServletRequest().getSession();
//            if (session != null) {
//                // 从 HTTP Session 中获取用户信息
//                User user = (User) session.getAttribute("user");
//                if (user != null) {
//                    // 将从 HTTP Session 中获取的用户信息存入 WebSocket 的 Attributes 对象中
//                    attributes.put("user", user);
//                    // 继续握手
//                    return true;
//                }
//            }
            // 终止握手
            return true;
        }

        /**
         * 握手完成后调用
         *
         * @param request   请求对象
         * @param response  响应对象
         * @param wsHandler WebSocket 处理器
         * @param ex        异常信息
         */
        @Override
        public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response,
                                   WebSocketHandler wsHandler, Exception ex) {
            System.out.println("终止握手操作");
        }
    }

}

2、自定义WebSocketServer（核心server）
这里就开始踩坑之路了，我们先贴代码

import com.alibaba.fastjson.JSON;
import com.muses.im.dto.MessageInfoDto;
import com.muses.im.service.MessageApiService;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.jetty.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Component
//这个注解用于标识作用在类上，它的主要功能是把当前类标识成一个WebSocket的服务端
//注解的值用户客户端连接访问的URL地址
//userId 为当前连接(在线) WebSocket 的用户
@ServerEndpoint("/websocket/{userId}")
public class WebSocketServerEndpoint {

    /**
     * 项目启动时初始化，会初始化 websocket （非用户连接的），
     * spring 同时会为其注入 service，该对象的 service 不是 null，被成功注入。
     * 但是，由于 spring 默认管理的是单例，所以只会注入一次 service。当新用户进入聊天时，
     * 系统又会创建一个新的 websocket 对象，这时矛盾出现了：spring 管理的都是单例，
     * 不会给第二个 websocket 对象注入 service，所以导致只要是用户连接创建的 websocket 对象，都不能再注入了。
     */
    private static MessageApiService messageApiService;

    @Autowired
    public void setMessageApiService(MessageApiService messageApiService) {
        WebSocketServerEndpoint.messageApiService = messageApiService;
    }

    /**
     * 与某个客户端的连接对话，需要通过它来给客户端发送消息
     */
    private Session session;

    /**
     * 标识当前连接客户端的用户名
     */
    private String userId;

    /**
     * //连接的uri
     */
    private String uri;

    /**
     * 用于存所有的连接服务的客户端，这个对象存储是安全的
     */
    private static ConcurrentHashMap<String, WebSocketServerEndpoint> webSocketMap = new ConcurrentHashMap<>();

    /**
     * 建立连接的回调
     * session 建立连接的会话
     * userId 当前连接用户id   路径参数
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) throws IOException, InterruptedException {
        this.session = session;
        this.userId = userId;
        this.uri = session.getRequestURI().toString();
        WebSocketServerEndpoint webSocketServerEndpoint = webSocketMap.get(userId);
        //判断是否有重复的用户登陆(判断是否有连接)
        if (webSocketServerEndpoint != null) {
            sendMessageBySession(webSocketServerEndpoint.session, userId + "用户重复登陆");
            //删除缓存把新登陆的连接放入map中（同一个用户登陆多个，只推送最新登陆的一个）
            webSocketMap.remove(userId);
            webSocketMap.put(userId, this);
        } else {
            webSocketMap.put(userId, this);
        }
//        log.info("----[ WebSocket ]---- 用户id为 : {} 的用户进入WebSocket连接 ! 当前在线人数为 : {} 人 !--------", userId, webSocketMap.size());
        //在建立连接时推送未读消息
        int noNumber = messageApiService.getNoReadNum(Integer.valueOf(userId));
        if (noNumber > 0) {
            MessageInfoDto dto = new MessageInfoDto();
            dto.setDestUrl("http://chq-xzgzt.yundasys.com/im-web/index.html");
            dto.setMsgInfo("你有<i style='color:red;'>" + noNumber + "</i>条消息未处理");
            dto.setMsgTitle("通知");
            sendMessageById(userId, JSON.toJSONString(dto));
        }
    }

    /**
     * 关闭连接的回调
     * 移除用户在线状态
     */
    @OnClose
    public void onClose() {
        webSocketMap.remove(userId);
        log.info("----[ WebSocket ]---- 用户id为 : {} 的用户退出WebSocket连接 ! 当前在线人数为 : {} 人 !--------", userId, webSocketMap.size());
    }

    @OnMessage
    public void onMessage(String message, Session session, @PathParam("userId") String userId) {
        log.info("--------收到用户id为 : {} 的用户发送的消息 ! 消息内容为 : {}------------------", userId, message);
    }

    @OnError
    public void onError(Session session, Throwable error) {
        webSocketMap.remove(userId);
        log.error("----------------WebSocket发生错误：{}----------------",error.getMessage());
    }

    /**
     * 根据userId发送给用户
     *
     * @param userId
     * @param message
     */
    public void sendMessageById(String userId, String message) {
        if (StringUtil.isEmpty(userId)) {
            log.error("----[ WebSocket ]------给用户发送消息失败，失败原因：无用户信息---------");
            return;
        }
        sendMessageBySession(webSocketMap.get(userId).session, message);
    }

    /**
     * 根据Session发送消息给用户
     *
     * @param session
     * @param message
     */
    public void sendMessageBySession(Session session, String message) {
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            log.error("----[ WebSocket ]------给用户发送消息失败，失败原因：{}---------", e.getMessage());
        }
    }

    /**
     * 给在线用户发送消息
     *
     * @param message
     */
    public void sendMessageOnline(String message) {
        sendMessageBySession(webSocketMap.get(userId).session, message);
    }

    /**
     * 群发
     *
     * @param message
     */
    public void GroupSending(String message) {
        for (String name : webSocketMap.keySet()) {
            try {
                webSocketMap.get(name).session.getBasicRemote().sendText(message);
            } catch (Exception e) {
                log.error("----[ WebSocket ]----消息群发失败，失败原因：{}---------", e.getMessage());
            }
        }
    }

    /**
     * 指定发送
     *
     * @param name
     * @param message
     */
    public void AppointSending(String name, String message) {
        try {
            webSocketMap.get(name).session.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("----[ WebSocket ]----指定发送失败，失败原因：{}---------", e.getMessage());
        }
    }

好，那么此时就遇到了第一个坑：
如果服务部署到多个节点，而我们的websocket的session是保存在当前服务节点的本地的，并且我们要知道websocket一次只能与一个节点建立连接的。那么就会出现有一个节点能接收到消息，想想看是不是有的消息就丢失了呢

那么此时想到了第一个解决方案了：
针对消息丢失问题，我们把消息丢到RabbitMQ中，但是出现了另外一个问题，就是RabbitMQ的消息是平均分发消息的，这也就导致我们消息还是会丢失

第二个坑（RabbitMQ的平均分发消息）
那么我们此时想到了另外一个解决方案，我们把消费的消息通过redis的发布订阅来做（一个channel管道多个消费者订阅，订阅的消息是一样的），问题大致是解决了，也满足了我们现有的业务要求。但是我们要知道，redis的发布订阅也是会存在数据丢失的情况的，那么在什么情况下会丢失呢，在服务宕机、网络断网、我们服务重启的情况下，数据就会存在丢失。我们想到吧Session丢到redis，但是在websocket中session是无法序列化的。

第三个坑（Redis的分布订阅会存在消息丢失）
为了解决消息丢失问题，我们更换中间件，使用RocketMQ的广播消费来分发到每个节点上，这样我们的每个节点收到的消息都是相通的，也不需要redis来做发布订阅了，这样就不会存在消息丢失了

第四个坑（RocketMQ做即时通讯消息不实时）
唉，那么此时又遇到一个问题
如果我们把消息丢到队列和redis，那么我们如果做即时通讯的话，肯定会存在消息延迟的现象呀

我们最终解决方案代码贴上
我们先说下设计思路：
1、将我们当前连接的容器实例ip+sessionID等参数放入redis缓存，当请求过来的时候判断当前请求ip是否是我建立连接的ip，
2、若不是，通过转发调用建立连接的ip实例上去，建立连接的ip实例本身就存在session,所以转发过去可以直接推送
3、当我们去关闭连接或出现异常的时候，就会吧当前IP+sessionId从缓存中删除掉，这样连接是最新连接，不会重复推送多次

WebsokcetServer

@Component
@ServerEndpoint("/screenWebsocket/{serverClient}/{page}/{userId}")
@Slf4j
public class WebSocketServer {
    /**
     * concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
     * <p>
     * Map的key为userId,List用于存放一个userId的多个终端，比如同一个userId,同时在手机端和PC登陆
     */
    private static ConcurrentHashMap<String, List<WebSocketServer>> webSocketMap = new ConcurrentHashMap<>();
    /**
     * 与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    private Session session;
    /**
     * 接收userId
     */
    private String userId = "";

    /**
     * 全局唯一key
     */
    private String key = "";

    private static final String PORT_STR = ":31882";

    /**
     * 自己封装的redis的工具类，用于将数据存放于redis,解决分布式下多服务器共享session
     */

    private static RedisTemplate redisTemplate;

    @Autowired
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        WebSocketServer.redisTemplate = redisTemplate;
    }

    /**
     * 存储websocket客户端接入的信息key前缀
     */
    public static final String WEBSOCKET_REDIS_KEY_PREFIX = "WebSocket_";

    public static final String REDISSON_LOCK_KEY = "redisLockKey";

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("serverClient") String serverClient, @PathParam("page") String page, @PathParam("userId") String userId) throws IOException {
        this.session = session;
        this.userId = userId;
        this.key = serverClient + page + userId;
        List<WebSocketServer> servers;

        String ipAddress = IPUtils.getIpAddress();
        log.info("通过另外一种方式获取的当前容器连接的ip:【{}】", ipAddress);

        List<WebSocketServer> webSocketServers = new ArrayList<>();
        if (!ObjectUtils.isEmpty(redisTemplate.opsForValue().get(getSocketRedisKey(key)))) {
            redisTemplate.delete(getSocketRedisKey(key));
            sendMessage("----------->这位<帅哥> OR <美女>，你重复登陆了哟<----------");
        }
        //将接入的客户端信息添加到内存
        if (webSocketMap.containsKey(key)) {
            //查询当前userId以及当前的session是否已经存在，如果存在，先移除再新增，如果不存在，直接新增
            webSocketServers = webSocketMap.get(key).stream().filter(o -> o.session.getId().equals(session.getId())).collect(Collectors.toList());
        }
        if (webSocketMap.containsKey(key) && webSocketServers.size() > 0) {
            webSocketServers = webSocketMap.get(key);

            //这里不能直接使用remove删除，在并发情况下会有数组越界情况，的使用迭代器删除
            Iterator<WebSocketServer> it = webSocketServers.iterator();
            while (it.hasNext()) {
                if (it.next().session.getId().equals(session.getId())) {
                    it.remove();
                }
            }

            servers = webSocketServers;
            servers.add(this);
            webSocketMap.put(key, servers);
        } else {
            servers = null == webSocketMap.get(key) ? new ArrayList<>() : webSocketMap.get(key);
            servers.add(this);
            webSocketMap.put(key, servers);
        }
        log.info("用户【{}】sessionId:[{}]连接成功", key, session.getId());
        StorageRedis(session, userId, ipAddress);

    }

    /**
     * 将节点信息放入redis缓存
     *
     * @param session
     * @param userId
     * @param ipAddress
     */
    private void StorageRedis(Session session, @PathParam("userId") String userId, String ipAddress) {
        //region 将客户端连接信息存入redis
        try {
            /**
             * SocketUserInfoDTO
             *
             * 存储在redis中按照如下结构
             *                         ｜-- Ip
             *           -- sessionId1 ｜-- 其他信息
             *           --
             * userId -- -- sessionId2 ｜- ...
             *           --
             *           -- sessionId3 ｜-- Ip
             *           --            ｜-- 其他信息
             */
            SocketUserInfoDTO suid = null;
            SocketUserInfoSessionDTO socketUserInfoSessionDTO = new SocketUserInfoSessionDTO();
            socketUserInfoSessionDTO.setSessionId(session.getId());
            socketUserInfoSessionDTO.setUserId(userId);
            socketUserInfoSessionDTO.setKey(key);
            socketUserInfoSessionDTO.setIp(String.valueOf(new StringBuilder().append(ipAddress).append(PORT_STR)));
            log.info("获取到的当前容器的ip--->【{}】", ipAddress);
            //需要从redis拉最新的客户端连接信息
            Object object = redisTemplate.opsForValue().get(getSocketRedisKey(key));
            if (!ObjectUtils.isEmpty(object)) {
                suid = JSON.parseObject(object.toString(), SocketUserInfoDTO.class);
            }
            SocketUserInfoDTO socketUserInfoDTO = new SocketUserInfoDTO();
            if (ObjectUtils.isEmpty(suid)) {  //当前user没有保存的socket信息
                Map<String, Map<String, SocketUserInfoSessionDTO>> listMap = new HashMap<>();
                Map<String, SocketUserInfoSessionDTO> map = new HashMap<>();
                map.put(session.getId(), socketUserInfoSessionDTO);
                listMap.put(key, map);
                socketUserInfoDTO.setListMap(listMap);
                //保存到redis
                redisTemplate.opsForValue().set(getSocketRedisKey(key), JSON.toJSONString(socketUserInfoDTO));
            } else { //当前user有保存的socket信息
                Map<String, Map<String, SocketUserInfoSessionDTO>> map = suid.getListMap();
                Map<String, SocketUserInfoSessionDTO> sessionDTOMap = map.get(key);
                sessionDTOMap.put(session.getId(), socketUserInfoSessionDTO);
                map.put(key, sessionDTOMap);
                socketUserInfoDTO.setListMap(map);
                redisTemplate.opsForValue().set(getSocketRedisKey(key), JSON.toJSONString(socketUserInfoDTO));
            }
            WsMessage msg = new WsMessage();
            ForwardSocketUserInfoRequest dto = new ForwardSocketUserInfoRequest();
            msg.setType((byte) 2);
            dto.setMsgInfo("--------------->哦哟，恭喜你呀，你连接成功了，普天同庆<----------");
            msg.setForwardSocketUserInfoRequest(dto);
            sendMessage(JSON.toJSONString(msg));
        } catch (IOException e) {
            log.error("用户:" + key + ",网络异常!!!!!!");
        }
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        List<WebSocketServer> webSocketServers = new ArrayList<>();
        if (webSocketMap.containsKey(key)) {
            webSocketServers = webSocketMap.get(key).stream().filter(o -> o.session.getId().equals(session.getId())).collect(Collectors.toList());
            if (webSocketServers.size() > 0) {
                webSocketServers = webSocketMap.get(key);
                Iterator<WebSocketServer> iterator = webSocketServers.iterator();
                while (iterator.hasNext()) {
                    if (iterator.next().session.getId().equals(session.getId())) {
                        iterator.remove();
                    }
                }
                webSocketMap.put(key, webSocketServers);
                log.info("用户【" + key + "】sessionId:[" + session.getId() + "]断开连接");
            }
        }

        //从redis中移除对应的客户端
        Object redisSocketObj = redisTemplate.opsForValue().get(getSocketRedisKey(key));
        SocketUserInfoDTO suid = null;
        if (!ObjectUtils.isEmpty(redisSocketObj)) {
            String resultStr = redisSocketObj.toString();
            suid = JSON.parseObject(resultStr, SocketUserInfoDTO.class);
        }
        if (!ObjectUtils.isEmpty(suid)) {
            Map<String, Map<String, SocketUserInfoSessionDTO>> map = suid.getListMap();
            Map<String, SocketUserInfoSessionDTO> sessionDTOMap = map.get(key);
            Iterator<Map.Entry<String, SocketUserInfoSessionDTO>> entryIterator = sessionDTOMap.entrySet().iterator();
            while (entryIterator.hasNext()) {
                Map.Entry<String, SocketUserInfoSessionDTO> entry = entryIterator.next();
                if (session.getId().equals(entry.getValue().getSessionId())) {
                    entryIterator.remove();
                }
            }
            if (sessionDTOMap.size() <= 0) {
                map.remove(key);
            }
            SocketUserInfoDTO socketUserInfoDTO = new SocketUserInfoDTO();
            if (map.size() <= 0) {
                redisTemplate.delete(getSocketRedisKey(key));
            } else {
                socketUserInfoDTO.setListMap(map);
                redisTemplate.opsForValue().set(getSocketRedisKey(key), JSON.toJSONString(socketUserInfoDTO));
            }
        }
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("用户【" + key + "】sessionId:[" + session.getId() + "]发送消息给服务端报文:" + message);
//        log.info("session" + session.getBasicRemote() + "|" + session.getId());
        try {
            sendMessage("服务端消息：" + "用户" + key + "收到客户端的消息");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //可以群发消息
        //消息保存到数据库、redis
    }

    /**
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("用户错误:" + this.key + ",原因:" + error.getMessage());
    }

    /**
     * 实现服务器主动推送
     */
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }

    /**
     * 发送自定义消息
     */
    public static void sendInfo(String message, @PathParam("key") String key, String sessionId) throws IOException {
        log.info("发送消息到用户【" + key + "】sessionId:[" + sessionId + "]发送消息给客户端报文:" + message);
        log.info(JSON.toJSONString("当前客户" + key + "的所有客户端：" + webSocketMap.get(key)));
        if (StringUtils.isNotBlank(key) && webSocketMap.containsKey(key)) {
            for (WebSocketServer webSocketServer : webSocketMap.get(key)) {
                //1、如果不考虑websocket有多台服务器的情况下，可以不用判断，推送消息的时候对该用户的所有终端都推送
                //2、当然如果业务需求不需要多终端推送，哪个终端有消息，就推送哪个，这里就不需要修改
                if (sessionId.equals(webSocketServer.session.getId())) {
                    webSocketServer.sendMessage(message);
                }
            }
        } else {
            log.error("用户" + key + ",不在线！");
        }
    }


    /**
     * 构造redis的key值
     *
     * @param userId
     * @return
     */
    private String getSocketRedisKey(String userId) {
        return WEBSOCKET_REDIS_KEY_PREFIX + userId;
    }

    @Data
    static class SessionInfo {
        private String address;

        private String port;
    }

相关的POJO

/**
 * 为了使用方便，将保存的客户端信息保存为map
 */
@Data
public class SocketUserInfoDTO implements Serializable {
    private static final long serialVersionUID = 1L;
    private Map<String, Map<String, SocketUserInfoSessionDTO>> listMap;
}
 
/**
 * 存储客户端连接的信息，根据自己的情况，可以存一些业务参数，方便后面使用
 */
@Data
public class SocketUserInfoSessionDTO implements Serializable {
    private static final long serialVersionUID = 1L;
    //WebSocket Session 的sessionId
    private String sessionId;
    //userId
    private String userId;
    //客户端创建连接时候的服务器IP+端口号
    private String ip;
}
 
@Data
public class ForwardSocketUserInfoRequest {
    private String sessionId;
    private String userId;
    private String json;
}

实现HTTP消息转发接口

socketSend接口：消息服务统一将消息通过该接口发送处理

forwardSend接口：由websocket服务内部根据IP做消息转发

@RestController
@RequestMapping("/websocket")
public class WebSocketController {
 
    @Resource
    private WebSocketService webSocketService;
 
    /**
     * @param request
     * @return
     */
    @RequestMapping(value = "/socketSend", method = RequestMethod.POST)
    @ResponseBody
    Result socketSend(@RequestBody ForwardSocketUserInfoRequest request) {
        return webSocketService.socketSend(request);
    }
 
    /**
     * 该接口供本服务内部通过转发到对用的服务器发送http调用
     * @param request
     * @return
     */
    @RequestMapping(value = "/forwardSend", method = RequestMethod.POST)
    @ResponseBody
    Result forwardSend(@RequestBody ForwardSocketUserInfoRequest request) {
        return webSocketService.forwardSend(request);
    }
}

Service Interface

public interface IWebSocketService {

    /**
     * 处理需要发送socket消息的任务
     *
     * @param request
     */
    Message socketSend(ForwardSocketUserInfoRequest request);

    /**
     * 该接口供本服务内部通过转发到对用的服务器发送http调用
     *
     * @param request
     * @return
     */
    Message forwardSend(ForwardSocketUserInfoRequest request);

}

实现类IMPL

@Slf4j
@Service
public class WebSocketServiceImpl implements IWebSocketService {

    @Resource
    private RedisTemplate redisTemplate;

    private static final String SERVER_PORT = "31882";

    @Override
    public Message socketSend(ForwardSocketUserInfoRequest request) {
        String redisKey = WebSocketServer.WEBSOCKET_REDIS_KEY_PREFIX + request.getKey();
        Object redisSocketObj = redisTemplate.opsForValue().get(redisKey);
        SocketUserInfoDTO socketUserInfoDTO = null;
        if (!ObjectUtils.isEmpty(redisSocketObj)) {
            String resultStr = redisSocketObj.toString();
            socketUserInfoDTO = JSONObject.parseObject(resultStr, SocketUserInfoDTO.class);
        }
        if (ObjectUtils.isEmpty(socketUserInfoDTO)) {
            log.error("给用户推送websocket消息失败");
            return new Message();
        }
        Map<String, Map<String, SocketUserInfoSessionDTO>> mapMap = socketUserInfoDTO.getListMap();
        Map<String, SocketUserInfoSessionDTO> sessionDTOMap = mapMap.get(request.getKey());
        //遍历map,根据Ip通过HTTP方式，传入sessionId参数，调用推送信息接口（这里的接口需要根据sessionId从内存中的map拿到对应的websocket,然后发送消息），推送信息到客户端
        Iterator<Map.Entry<String, SocketUserInfoSessionDTO>> entryIterator = sessionDTOMap.entrySet().iterator();
        while (entryIterator.hasNext()) {
            Map.Entry<String, SocketUserInfoSessionDTO> entry = entryIterator.next();
            String ipAndPort = String.valueOf(new StringBuilder().append(IPUtils.getIpAddr()).append(":").append(SERVER_PORT));
            if (ipAndPort.equals(entry.getValue().getIp())) {  //如果是本台服务器，直接发送
                try {
                    WsMessage msg = new WsMessage();
                    msg.setType((byte) 1);
                    msg.setForwardSocketUserInfoRequest(request);
                    WebSocketServer.sendInfo(JSON.toJSONString(msg), request.getKey(), entry.getValue().getSessionId());
                } catch (IOException e) {
                    log.error("消息发送失败：{}",e.getMessage());
                }
            } else {
                request.setSessionId(entry.getValue().getSessionId());
                //通过HTTP转发到对应的服务器做处理
                HttpUtils.sendPost("http://" + entry.getValue().getIp() + "/forwardSend",
                        JSON.toJSONString(request));
            }
        }
        return new Message();
    }

    @Override
    public Message forwardSend(ForwardSocketUserInfoRequest request) {
        try {
            WsMessage msg = new WsMessage();
            msg.setType((byte) 1);
            msg.setForwardSocketUserInfoRequest(request);
            WebSocketServer.sendInfo(JSON.toJSONString(msg), request.getKey(), request.getSessionId());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new Message();
    }
}

这里顺便把工具类贴出来吧

@Slf4j
public class IPUtils {
    private static Logger logger = LoggerFactory.getLogger(IPUtils.class);
    public static String getIpAddr() {
        HttpServletRequest request =  ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            logger.error("IPUtils ERROR ", e);
        }
        return ip;
    }

    public static String getIpAddress() {
        try {
            Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
            InetAddress ip = null;
            while (allNetInterfaces.hasMoreElements()) {
                NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
                if (netInterface.isLoopback() || netInterface.isVirtual() || !netInterface.isUp()) {
                    continue;
                } else {
                    Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                    while (addresses.hasMoreElements()) {
                        ip = addresses.nextElement();
                        if (ip != null && ip instanceof Inet4Address) {
                            return ip.getHostAddress();
                        }
                    }
                }
            }
        } catch (Exception e) {
            System.err.println("IP地址获取失败" + e.toString());
        }
        return "";
    }

}

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 初始化string的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        redisTemplate.setValueSerializer(stringRedisSerializer);
        // hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}