关于springBoot中集成websocket，多终端共享session解决方案

知识点

WebSocket和Http：

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

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

HTTP协议是用在应用层的协议，他是基于tcp协议的，http协议建立链接也必须要有三次握手才能发送信息。http链接分为短链接，长链接，短链接是每次请求都要三次握手才能发送自己的信息。即每一个request对应一个response。长链接是在一定的期限内保持链接。保持TCP连接不断开。客户端与服务器通信，必须要有客户端发起然后服务器返回结果。客户端是主动的，服务器是被动的。

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

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

   如果不是持续连接，即短连接，那么每个资源都要建立一个新的连接，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、添加配置类

@Configuration
public class WebSocketConfig {
    /**
     * ServerEndpointExporter 作用
     *
     * 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
     *
     * @return
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

注意：ServerEndpointExporter一定要注入，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint；如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。

2、自定义WebSocketServer（核心Server）

这里有两个问题：

• 如果是单台实例，其实我们大可不必使用redis进行共享session；但如果是分布式，客户端创建的连接是随机的，可能与服务器A创建了连接，也可能是服务器B,如果仅仅将连接信息存到内存，那就有问题了

• WebsocketSession 不支持序列化，所以不能直接将Session对象存储到redis中

这里只是其中的一种解决方法，A、B服务器的session依然保存在各自的服务器中，然后将userid、sessionId、服务端服务器的IP的关系保存在redis中；当然这个sessionId你也可以不用，你可以在拿到websocket的session的时候，给他赋予一个唯一ID,并把这个ID和websocket session存入内存，同时将该关系以及当前创建的服务器IP保存到redis中；

如何使用？需要发送消息的时候，根据userId从redis中获取对应的关系，再根据对应的IP转发到对用的websocket服务器上即可

sessionId是由org.apache.tomcat.websocket.WsSession生成的一个递增的16进制并转为字符串,每次重启服务,这个id的计数又会重新从0开始。如果建立了多个通道,那他们的id可能为(0,1818,70cc).因为通道断开,对应的webSocketSession对象被释放,所以不同通道直接的id可能是不连续的.

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

@Component
@ServerEndpoint("/websocket/{userId}")
@Slf4j
public class WebSocketServer {
    /**
     * 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
     */
    private static int onlineCount = 0;
    /**
     * 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 = "";

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

    @Autowired
    public void setChatService(RedisUtils redisUtils) {
        WebSocketServer.redisUtils = redisUtils;
    }

    /**
     * 读取配置文件中的配置数据
     */
    private static ValueConfig valueConfig;

    @Autowired
    public void setValueConfig(ValueConfig valueConfig) {
        WebSocketServer.valueConfig = valueConfig;
    }

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

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        this.session = session;
        this.userId = userId;
        List<WebSocketServer> servers;
        List<WebSocketServer> webSocketServers = new ArrayList<>();
        //将接入的客户端信息添加到内存
        if (webSocketMap.containsKey(userId)) {
            //查询当前userId以及当前的session是否已经存在，如果存在，先移除再新增，如果不存在，直接新增
            webSocketServers = webSocketMap.get(userId).stream().filter(o -> o.session.getId().equals(session.getId())).collect(Collectors.toList());
        }
        if (webSocketMap.containsKey(userId) && webSocketServers.size() > 0) {
            webSocketServers = webSocketMap.get(userId);
            webSocketServers.removeIf(webSocketServer -> webSocketServer.session.getId().equals(session.getId()));
            servers = webSocketServers;
            servers.add(this);
            webSocketMap.put(userId, servers);
        } else {
            servers = null == webSocketMap.get(userId) ? new ArrayList<>() : webSocketMap.get(userId);
            servers.add(this);
            webSocketMap.put(userId, servers);
            addOnlineCount();//在线数加1
        }
        log.info("用户【" + userId + "】sessionId:[" + session.getId() + "]连接成功" + ",当前在线人数为:" + getOnlineCount());
        //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.setIp(IpUtils.getServerIpAddress() + ":" + valueConfig.getServicePort());
            //需要从redis拉最新的客户端连接信息
            Object object = redisUtils.get(getSocketRedisKey(userId));
            if (null != object) {
                suid = JSONObject.parseObject(object.toString(), SocketUserInfoDTO.class);
            }
            SocketUserInfoDTO socketUserInfoDTO = new SocketUserInfoDTO();
            if (null == suid) {  //当前user没有保存的socket信息
                Map<String, Map<String, SocketUserInfoSessionDTO>> listMap = new HashMap<>();
                Map<String, SocketUserInfoSessionDTO> map = new HashMap<>();
                map.put(session.getId(), socketUserInfoSessionDTO);
                listMap.put(userId, map);
                socketUserInfoDTO.setListMap(listMap);
                //保存到redis
                redisUtils.set(getSocketRedisKey(userId), JSONObject.toJSONString(socketUserInfoDTO));
            } else { //当前user有保存的socket信息
                Map<String, Map<String, SocketUserInfoSessionDTO>> map = suid.getListMap();
                Map<String, SocketUserInfoSessionDTO> sessionDTOMap = map.get(userId);
                sessionDTOMap.put(session.getId(), socketUserInfoSessionDTO);
                map.put(userId, sessionDTOMap);
                socketUserInfoDTO.setListMap(map);
                redisUtils.set(getSocketRedisKey(userId), JSONObject.toJSONString(socketUserInfoDTO));
            }
            sendMessage("连接成功");
        } catch (IOException e) {
            log.error("用户:" + userId + ",网络异常!!!!!!");
        }
        //endregion
    }


    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        List<WebSocketServer> webSocketServers = new ArrayList<>();
        if (webSocketMap.containsKey(userId)) {
            webSocketServers = webSocketMap.get(userId).stream().filter(o -> o.session.getId().equals(session.getId())).collect(Collectors.toList());
        }
        if (webSocketMap.containsKey(userId) && webSocketServers.size() > 0) {
            webSocketServers = webSocketMap.get(userId);
            Iterator<WebSocketServer> iterator = webSocketServers.iterator();
            while (iterator.hasNext()) {
                if (iterator.next().session.getId().equals(session.getId())) {
                    iterator.remove();
                }
            }
            webSocketMap.put(userId, webSocketServers);
            subOnlineCount();
            log.info("用户【" + userId + "】sessionId:[" + session.getId() + "]断开连接,当前在线人数为:" + getOnlineCount());
        }
        //从redis中移除对应的客户端
        Object redisSocketObj = redisUtils.get(getSocketRedisKey(userId));
        SocketUserInfoDTO suid = null;
        if (null != redisSocketObj) {
            String resultStr = redisSocketObj.toString();
            suid = JSONObject.parseObject(resultStr, SocketUserInfoDTO.class);
        }
        if (null != suid) {
            Map<String, Map<String, SocketUserInfoSessionDTO>> map = suid.getListMap();
            Map<String, SocketUserInfoSessionDTO> sessionDTOMap = map.get(userId);
            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(userId);
            }
            SocketUserInfoDTO socketUserInfoDTO = new SocketUserInfoDTO();
            if (map.size() <= 0) {
                redisUtils.del(getSocketRedisKey(userId));
            } else {
                socketUserInfoDTO.setListMap(map);
                redisUtils.set(getSocketRedisKey(userId), JSONObject.toJSONString(socketUserInfoDTO));
            }
        }
    }

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

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

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


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

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

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

相关的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 Object object;
}

3

实现HTTP消息转发接口

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

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

Controller:

@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 WebSocketService {
    /**
     * 处理需要发送socket消息的任务
     *
     * @param request
     */
    Result socketSend(ForwardSocketUserInfoRequest request);

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

实现Impl：

@Slf4j
@Service
public class WebSocketServiceImpl implements WebSocketService {
    
    @Resource
    private RedisUtils redisUtils;

    @Value("${server.port}")
    private String servicePort;

    /**
     * 根据redis中存入的websocket客户端接入信息，转发到对应的服务器做消息推送
     *
     * @param request
     */
    @Override
    public Result socketSend(ForwardSocketUserInfoRequest request) {
        String redisKey = WebSocketServer.websocketRedisKeyPrefix + request.getUserId();
        Object redisSocketObj = redisUtils.get(redisKey);
        SocketUserInfoDTO socketUserInfoDTO = null;
        if (null != redisSocketObj) {
            String resultStr = redisSocketObj.toString();
            socketUserInfoDTO = JSONObject.parseObject(resultStr, SocketUserInfoDTO.class);
        }
        if (null == socketUserInfoDTO) {
            log.error("给用户推送websocket消息失败");
            return Result.buildSuccess();
        }
        Map<String, Map<String, SocketUserInfoSessionDTO>> mapMap = socketUserInfoDTO.getListMap();
        Map<String, SocketUserInfoSessionDTO> sessionDTOMap = mapMap.get(request.getUserId());
        //遍历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 = IpUtils.getServerIpAddress() + ":" + servicePort;
            if (ipAndPort.equals(entry.getValue().getIp())) {  //如果是本台服务器，直接发送
                try {
                    WebSocketServer.sendInfo(JSON.toJSONString(request.getObject()), request.getUserId(), entry.getValue().getSessionId());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } else {
                request.setSessionId(entry.getValue().getSessionId());
                //通过HTTP转发到对应的服务器做处理
                JnHttpUtils.post(JSON.toJSONString(request),
                        "http://" + entry.getValue().getIp() + "/websocket/forwardSend");
            }
        }
        return Result.buildSuccess();
    }

    /**
     * 该接口供本服务内部通过转发到对用的服务器发送http调用
     *
     * @param request
     * @return
     */
    @Override
    public Result forwardSend(ForwardSocketUserInfoRequest request) {
        try {
            WebSocketServer.sendInfo(JSON.toJSONString(request.getObject()), request.getUserId(), request.getSessionId());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return Result.buildSuccess();
    }
}

 测试日志这里就不截图啦~