Spring Boot 整合 WebSocket 使用记录

这里写自定义目录标题

  • 前言
  • WebSocket 简介
  • WebSocket 客户端(javascript前端)实现
    • javascript 实现
    • window.location获取URL中各部分
    • http/https与websocket的ws/wss的关系
  • WebSocket 服务端(java后台)实现
    • Maven 依赖
    • WebSocketServer 实现
    • WebSocketConfig 实现
    • MessageDecoder 实现
    • MessageEncoder 实现
  • 问题
    • 1. WebSocket服务端需要获取到用户使用数据库的用户信息登录后的HttpSession获取个人资料信息
    • 2. 项目打jar包报异常
      • 解决方式
    • 3. nginx转发无法连接
      • nginx转发需要配置nginx使nginx支持websocket连接:
    • 3. Nginx代理webSocket时60s自动断开 或者 WebSocket发生EOFException异常
      • 解决方式
        • 1. 将心跳间隔调小,小于nginx默认超时时间60s
        • 2. 将nginx超时时间设置大一点
    • 4. 使用war包启动,启动异常
      • 解决方式
        • 1. 注释注入ServerEndpointExporter的代码

前言

由于项目需要定时将消息从Web端推送至客户端
通常使用的方式有:AJAX轮询、XHR长轮询、iframe、Comet、websocket等

部分详情可见:https://blog.csdn.net/qq_43225978/article/details/105396640

考虑实现的难度及复杂度,最终选用WebSocket方式。

WebSocket 简介

WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据。在 WebSocket API 中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。

在 WebSocket API 中,浏览器和服务器只需要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。

现在,很多网站为了实现推送技术,所用的技术都是 Ajax 轮询。轮询是在特定的的时间间隔(如每1秒),由浏览器对服务器发出HTTP请求,然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点,即浏览器需要不断的向服务器发出请求,然而HTTP请求可能包含较长的头部,其中真正有效的数据可能只是很小的一部分,显然这样会浪费很多的带宽等资源。

HTML5 定义的 WebSocket 协议,能更好的节省服务器资源和带宽,并且能够更实时地进行通讯。

Spring Boot 整合 WebSocket 使用记录_第1张图片

浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求,连接建立以后,客户端和服务器端就可以通过 TCP 连接直接交换数据。

当你获取 Web Socket 连接后,你可以通过 send() 方法来向服务器发送数据,并通过 onmessage 事件来接收服务器返回的数据。

以下 API 用于创建 WebSocket 对象。

WebSocket 简介及API
https://www.runoob.com/html/html5-websocket.html
http://www.ruanyifeng.com/blog/2017/05/websocket.html
https://developer.mozilla.org/zh-CN/docs/Web/API/WebSocket

WebSocket 客户端(javascript前端)实现

javascript 实现

// 心跳重试连接次数
var websocket_reconnected_count = 0;
var websocket = null;
// 初始化WebSocket连接
function initWebSocket() {
    websocket = null;
    // 判断当前环境是否支持websocket
    if(window.WebSocket){
        if(!websocket){
        	// 获取协议类型
            var protocol = window.location.protocol;
            // console.info(protocol)
            // 通过访问协议类型,判断使用的websocket协议类型
            var ws_url = protocol=='http:'?'ws://':'wss://'
            // 获取域名
            var host = window.location.host;
            // 获取端口号
            var port = window.location.port;
            // 获取项目访问路由
            var pathName = window.location.pathname;
            // 截取项目名
            var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);
            // 拼接websocket访问地址
            ws_url += host + projectName + "/webSocket/user_1";
            // console.info(ws_url);
            // 创建websocket对象
            websocket = new WebSocket(ws_url);
        }
    }else{
        var content = '【当前浏览器不支持WEBSOCKET,无法获取预警提醒消息,为获得良好的使用体验,推荐您下载使用Chrome浏览器】';
        alter(content);
    }

    //连接成功建立的回调方法
    websocket.onopen = function () {
        console.log('WebSocket连接成功');
        // 成功建立连接后,重置心跳检测
        heartCheck.reset().start();
    }
    //连接发生错误的回调方法
    websocket.onerror = function () {
        console.log('WebSocket连接发生错误');
    };
    //接收到消息的回调方法
    websocket.onmessage = function (event) {
        // console.log("=====WebSocket接收到消息=====");
        // console.log(event);
        // console.log(event.data);
		
		// 当服务端的会话不存在时,返回标志
		if(event.data=="\"sessionIsNulltrue\""){
            // 断开ws
            websocket.close();
            // 因为是会话过期,所以心跳重试链接机制的次数websocket_reconnected_count归零
            websocket_reconnected_count=0;
            // 重置清空心跳
            heartCheck.reset();
            // 使用layui弹窗提醒
            parent.layer.open({
                content: "会话过期!请重新登录!"
                ,btn: '确定',
                closeBtn : false,
                yes: function(index, layero){
                    //按钮【按钮一】的回调
                    // console.info("=======")
                    parent.layer.closeAll();
                    // 跳转至主页
                    window.top.location.href = Common.ctxPath + "/"
                }
            });
        }

        // 如果获取到消息,说明连接是正常的,重置心跳检测
        heartCheck.reset().start();
    }
    //连接关闭的回调方法
    websocket.onclose = function () {
        console.log('WebSocket连接关闭');
    }

    //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
    window.onbeforeunload = function () {
        // 关闭WebSocket连接
        websocket.close();
    }
}
// 心跳检测, 每隔一段时间检测连接状态,如果处于连接中,就向server端主动发送消息,来重置server端与客户端的最大连接时间,如果已经断开了,发起重连。
var heartCheck = {
 	// 30s 发一次心跳,比server端设置的连接时间稍微小,在接近断开的情况下以通信的方式去重置连接时间。
    timeout: 30000,
    serverTimeoutObj: null,
    reset: function(){
	    var self = this;
        clearTimeout(self.timeout);
        clearInterval(self.serverTimeoutObj);
        return self;
    },
    start: function(){
        var self = this;
        this.serverTimeoutObj = setInterval(function(){
            if(websocket.readyState == 1){
                console.log("连接状态,心跳保持连接");
                websocket.send("ping");
                heartCheck.reset().start();    // 如果获取到消息,说明连接是正常的,重置心跳检测
            }else{
                if(websocket_reconnected_count>0){
                   --websocket_reconnected_count;
                    console.log("断开状态,尝试重连");
                    initWebSocket();
                }else {
                    heartCheck.reset();
                }
            }
        }, self.timeout)
    }
}

window.location获取URL中各部分

对于这样一个URL
http://www.x2y2.com:80/fisker/post/0703/window.location.html?ver=1.0&id=6#imhere

我们可以用javascript获得其中的各个部分
1, window.location.href
      整个URl字符串(在浏览器中就是完整的地址栏)
      本例返回值: http://www.x2y2.com:80/fisker/post/0703/window.location.html?ver=1.0&id=6#imhere

2,window.location.protocol
      URL 的协议部分
      本例返回值:http:

3,window.location.host
      URL 的主机部分
      本例返回值:www.x2y2.com

4,window.location.port
      URL 的端口部分
      如果采用默认的80端口(update:即使添加了:80),那么返回值并不是默认的80而是空字符
      本例返回值:""

5,window.location.pathname
      URL 的路径部分(就是文件地址)
      本例返回值:/fisker/post/0703/window.location.html

6,window.location.search
      查询(参数)部分
      除了给动态语言赋值以外,我们同样可以给静态页面,并使用javascript来获得相信应的参数值
      本例返回值:?ver=1.0&id=6

来源 : https://www.cnblogs.com/chaoyuehedy/p/5708165.html

http/https与websocket的ws/wss的关系

websocket在http与https不同协议下实际上按照标准来是有如下对应关系的:
	http -> new WebSocket('ws://xxx')
	https -> new WebSocket('wss://xxx')
也就是在https下应该使用wss协议做安全链接,且wss下不支持ip地址的写法,写成域名形式

部分报错的浏览器的确是因为这个原因导致的代码异常,即在https下把ws换成wss请求即可,看到这里心细的也许会发现,是部分浏览器,实际上浏览器并没有严格的限制http下一定使用ws,而不能使用wss,经过测试http协议下同样可以使用wss协议链接,https下同样也能使用ws链接,那么出问题的是哪一部分呢
1.Firefox环境下https不能使用ws连接

2.chrome内核版本号低于50的浏览器是不允许https下使用ws链接

3.Firefox环境下https下使用wss链接需要安装证书

实际上主要是问题出在Firefox以及低版本的Chrome内核浏览器上,于是在http与https两种协议都支持的情况下可以做兼容处理,即在http协议下使用ws,在https协议下使用wss

可使用以下方式拼接websocket访问地址:
var protocol = windows.location.protocol === 'https:' ? 'wss://localhost:8888'  : 'ws://localhost:8889';

来源 : https://blog.csdn.net/garrettzxd/article/details/81674251

WebSocket 服务端(java后台)实现

Maven 依赖


	org.springframework.boot
	spring-boot-starter-websocket

WebSocketServer 实现

package com.xxx.xxxx.webSocket.server;


import com.alibaba.fastjson.JSONObject;
import com.xxx.xxxx.webSocket.MessageCoder.MessageDecoder;
import com.xxx.xxxx.webSocket.MessageCoder.MessageEncoder;
import com.xxx.xxxx.webSocket.config.WebSocketConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
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.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author xnz
 * @date 2020/03/31
 * @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端,
 * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
 */
@Component
@ServerEndpoint( value = "/webSocket/{id}",configurator = WebSocketConfig.class, encoders = { MessageEncoder.class }, decoders = { MessageDecoder.class } )
public class WebSocketServer {
    private static Logger log = LoggerFactory.getLogger(WebSocketServer.class);

    @PostConstruct
    public void init() {
        System.out.println("[WebSocket 加载]");
    }
    /**
     * 静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
     */
    private static final AtomicInteger ONLINECOUNT = new AtomicInteger(0);
    /**
     * 线程安全map,实现服务端与单一客户端通信,其中Key为用户标识  用来存放 与某个客户端的连接会话,需要通过它来给客户端发送数据
     */
    public static ConcurrentHashMap<String,Session> sessionMap = new ConcurrentHashMap<>();
    /**
     * 线程安全list,用来存放 在线客户端账号所属的组织id
     */
    public static List<Long> orgIdList = new CopyOnWriteArrayList<>();
    /**
     * 对应客户端id
     */
    private String sessionId = "";
//    private static Long currentId = null;

    /**
     * 连接建立成功调用的方法
     * @param id
     * @param session
     * @param config    用来获取WebSocketConfig中的配置信息
     * @throws IOException
     */
    @OnOpen
    public void onOpen(@PathParam(value = "id") String id, Session session, EndpointConfig config) throws IOException {
//        currentId = (Long) config.getUserProperties().get("currentId");

        log.info("========" + id);
        // 将当前会话账户所属组织id存储
        String[] userId = id.split("_");
        orgIdList.add(Long.valueOf(userId[1]));

        id = UUID.randomUUID().toString()+id;
        // 存储当前会话
        sessionMap.put(id,session);

        sessionId = id;
        int count = ONLINECOUNT.incrementAndGet();
        log.info("有连接加入,当前连接数为:{}", count);
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session) {
        try {
            session.close();

            sessionMap.remove(sessionId);

            String[] split = sessionId.split("_");
            orgIdList.remove(Long.valueOf(split[1]));
            int count = ONLINECOUNT.decrementAndGet();
            log.info("有连接关闭,当前连接数为:{}", count);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) throws IOException, InterruptedException {
        log.info("来自客户端 {} 的消息:{} , 当前连接数为:{}",sessionId,message,ONLINECOUNT.get());
        //        sendMessage(session, JSON.toJSONString(message));
    }

    /**
     * 出现错误
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误,Session ID : {}",session.getId());
        error.printStackTrace();
    }

    /**
     * 指定Session发送消息,实践表明,每次浏览器刷新,session会发生变化。
     * @param session
     * @param message
     */
    private static void sendMessage(Session session, Object message) {
        try {
            session.getBasicRemote().sendText(JSONObject.toJSONString(message));
//            session.getBasicRemote().sendObject(message);
        } catch (Exception e) {
            log.error("发送消息出错:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 通过id 获取会话 发送消息
     *
     * @param message   发送的消息
     */
    public static void sendMessageByOrgId(Object message,Long id)  {
        try {
            Set<Map.Entry<String, Session>> entries = sessionMap.entrySet();
            for (Map.Entry<String,Session>  item : entries) {
                String sessionId = item.getKey();
                if(sessionId.contains(id)){
                    log.info("[===发送消息至===] " + sessionId);
                    Session session = item.getValue();
                    sendMessage(session,message);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

WebSocketConfig 实现

package com.xxx.xxxx.webSocket.config;

import org.apache.catalina.session.StandardSessionFacade;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

import javax.servlet.http.HttpSession;
import javax.websocket.HandshakeResponse;
import javax.websocket.server.HandshakeRequest;
import javax.websocket.server.ServerEndpointConfig;

/**
 * 主要的配置类
 * 本类必须要继承Configurator,因为@ServerEndpoint注解中的config属性只接收这个类型
 */
@Configuration
public class WebSocketConfig extends ServerEndpointConfig.Configurator {
    private static final Logger log = LoggerFactory.getLogger(WebSocketConfig.class);

    /**
     * 修改握手,就是在握手协议建立之前修改其中携带的内容
     * @param sec
     * @param request
     * @param response
     */
    @Override
    public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
        /*如果没有监听器,那么这里获取到的HttpSession是null*/
        StandardSessionFacade ssf = (StandardSessionFacade) request.getHttpSession();
        if (ssf != null) {
            HttpSession session = (HttpSession) request.getHttpSession();
            sec.getUserProperties().put("session", session);
            log.info("获取到的SessionID:{}",session.getId());
//            User currentUser = (User) session.getAttribute("currentUser");
//            log.info("获取当前用户currentId:{}",currentUser.getId());
//            sec.getUserProperties().put("currentId", currentUser.getId());
        }else{
            System.out.println("modifyHandshake 获取到null session");
        }
        super.modifyHandshake(sec, request, response);
    }
    /**
     *  注入ServerEndpointExporter,
     *  这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

MessageDecoder 实现


package com.xxx.xxxx.webSocket.MessageCoder;

import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.websocket.DecodeException;
import javax.websocket.Decoder;
import javax.websocket.EndpointConfig;


public class MessageDecoder implements Decoder.Text<String>{

    private static Logger log = LoggerFactory.getLogger(MessageDecoder.class);

    @Override
    public String decode(String jsonMessage) throws DecodeException {
        log.info("MessageDecoder decode");
        return JSON.parseObject(jsonMessage, String.class);
    }

    @Override
    public boolean willDecode(String jsonMessage) {
        if(StringUtils.isBlank(jsonMessage))
            return false;
        try {
            JSON.parseObject(jsonMessage);
            return true;
        } catch (Exception e) {
            log.info("Message not jsonString");
            return false;
        }
    }

    @Override
    public void init(EndpointConfig endpointConfig) {
        log.info("MessageDecoder init");
    }

    @Override
    public void destroy() {
        log.info("MessageDecoder destroy");
    }
}


MessageEncoder 实现



package com.xxx.xxxx.webSocket.MessageCoder;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;

public class MessageEncoder implements Encoder.Text<String>{

    private static Logger log = LoggerFactory.getLogger(MessageEncoder.class);

    @Override
    public String encode(String s) throws EncodeException {
        return null;
    }

    @Override
    public void init(EndpointConfig endpointConfig) {
        log.info("MessageEncoder init");
    }

    @Override
    public void destroy() {
        log.info("MessageEncoder destroy");
    }
}

其他 WebSocket 客户端(javascript前端)及服务端(java后台)实现
https://www.cnblogs.com/freud/p/8397934.html
https://www.cnblogs.com/xdp-gacl/p/5193279.html
https://blog.csdn.net/Doctor_LY/article/details/81362718
spring boot Websocket(使用笔记):https://www.cnblogs.com/bianzy/p/5822426.html

问题

1. WebSocket服务端需要获取到用户使用数据库的用户信息登录后的HttpSession获取个人资料信息

在开发过程中想在 WebSocket服务端需要获取到用户使用数据库的用户信息登录后的HttpSession获取个人资料信息,通过搜索最后在WebSocketConfig类中的modifyHandshake方法中使用ServerEndpointConfig类sec.getUserProperties().put("currentId", currentUser.getId());方法,然后在onOpen方法中使用config.getUserProperties().get("currentId");获取。
详情可见上述实现类。

参考:
https://www.cnblogs.com/smallfa/p/9285844.html
https://www.cnblogs.com/coder163/p/8605645.html

2. 项目打jar包报异常

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverEndpointExporter' defined in org.lwt.WebsocketServerTestApplication: Invocation of init method failed; nested exception is java.lang.IllegalStateException: javax.websocket.server.ServerContainer not available
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1745) ~[spring-beans-5.1.4.RELEASE.jar:5.1.4.RELEASE]
	...

原因:
WebSocket是servlet容器所支持的,所以需要加载servlet容器:
webEnvironment参数为springboot指定ApplicationContext类型。
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT 表示内嵌的服务器将会在一个随机的端口启动。

解决方式

  1. 添加注解
@SpringBootTest(classes = WebsocketServerTestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
  1. 把pom里的test依赖删掉,删除测试类

	
	

  1. 使用war包时,springboot项目,去除内置tomcat的时候会把websocket的包也给删除掉,此时手动添加tomcat-embed-websocket包


    org.springframework.boot
    spring-boot-starter-tomcat
    provided




    org.apache.tomcat.embed
    tomcat-embed-websocket
    8.5.23

参考:
Error creating bean with name ‘serverEndpointExporter’ defined in class path —https://blog.csdn.net/kxj19980524/article/details/88751114
springboot整合websocket后运行测试类报错:javax.websocket.server.ServerContainer not available —https://blog.csdn.net/fggdgh/article/details/87185555

3. nginx转发无法连接

nginx转发需要配置nginx使nginx支持websocket连接:

server {
      listen   80;
      server_name 域名;
      location / {
      	# 代理转发地址
        proxy_pass   http://127.0.0.1:8080/;
        # 表明使用http版本为1.1
     proxy_http_version 1.1;
     # 超时设置 表明连接成功以后等待服务器响应的时候,如果不配置默认为60s;
        proxy_read_timeout   3600s;
        # 启用支持websocket连接
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
      }
}

其中重要的是这两行,它表明是websocket连接进入的时候,进行一个连接升级将http连接变成websocket的连接。

proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

来源 : Nginx 支持websocket的配置 — https://blog.csdn.net/weixin_37264997/article/details/80341911

3. Nginx代理webSocket时60s自动断开 或者 WebSocket发生EOFException异常

如果你的前端心跳间隔设置的大于60s,并且没有配置nginx超时时间,那么就会出现这个问题

解决方式

1. 将心跳间隔调小,小于nginx默认超时时间60s

2. 将nginx超时时间设置大一点

proxy_read_timeout   3600s;

借鉴 : Nginx代理webSocket时60s自动断开, 怎么保持长连接 — https://blog.csdn.net/cm786526/article/details/79939687

WebSocket使用注意事项:
心跳包切记不要放到initWebSocket()方法中,否则会产生递归循环调用并无限创建WebSocket对象,引发的结果就是nginx的连接数被刷爆,导致使用当前nginx的所以服务无法使用(相当于攻击),之前没注意,心已碎,偶买噶达!!!!!!

4. 使用war包启动,启动异常

9811 [localhost-startStop-1] ERROR org.springframework.boot.SpringApplication reportFailure 826 - Application run failed
java.lang.IllegalStateException: Failed to register @ServerEndpoint class: class com.motor.gdcollectioncms.webSocket.server.WebSocketServer
        at org.springframework.web.socket.server.standard.ServerEndpointExporter.registerEndpoint(ServerEndpointExporter.java:159)
        at org.springframework.web.socket.server.standard.ServerEndpointExporter.registerEndpoints(ServerEndpointExporter.java:134)
        at org.springframework.web.socket.server.standard.ServerEndpointExporter.afterSingletonsInstantiated(ServerEndpointExporter.java:112)
        at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:896)
        at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:878)
        at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:550)
        at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:141)
        at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:747)
        at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:397)
        at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
        at org.springframework.boot.web.servlet.support.SpringBootServletInitializer.run(SpringBootServletInitializer.java:152)
        at org.springframework.boot.web.servlet.support.SpringBootServletInitializer.createRootApplicationContext(SpringBootServletInitializer.java:132)
        at org.springframework.boot.web.servlet.support.SpringBootServletInitializer.onStartup(SpringBootServletInitializer.java:92)
        at org.springframework.web.SpringServletContainerInitializer.onStartup(SpringServletContainerInitializer.java:172)
        at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5245)
        at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)
        at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:754)
        at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:730)
        at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:734)
        at org.apache.catalina.startup.HostConfig.deployWAR(HostConfig.java:985)
        at org.apache.catalina.startup.HostConfig$DeployWar.run(HostConfig.java:1857)
        at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
        at java.util.concurrent.FutureTask.run(FutureTask.java:266)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
        at java.lang.Thread.run(Thread.java:748)
Caused by: javax.websocket.DeploymentException: Multiple Endpoints may not be deployed to the same path [/webSocket/{id}] : existing endpoint was [class com.motor.gdcollectioncms.webSocket.server.WebSocketServer] and new endpoint is [class com.motor.gdcollectioncms.webSocket.server.WebSocketServer]
        at org.apache.tomcat.websocket.server.WsServerContainer.addEndpoint(WsServerContainer.java:170)
        at org.apache.tomcat.websocket.server.WsServerContainer.addEndpoint(WsServerContainer.java:234)
        at org.springframework.web.socket.server.standard.ServerEndpointExporter.registerEndpoint(ServerEndpointExporter.java:156)
        ... 25 common frames omitted
javax.websocket.DeploymentException: Multiple Endpoints may not be deployed to the same path [/webSocket/{id}] : existing endpoint was [class com.motor.gdcollectioncms.webSocket.server.WebSocketServer] and new endpoint is [class com.motor.gdcollectioncms.webSocket.server.WebSocketServer]
即
javax.websocket。DeploymentException:多个端点可能没有部署到相同的路径[/webSocket/{id}]:现有的端点是[class com.motor.gdcollectioncms.webSocket.server]。新的端点是[class com.motor.gdcollectioncms. WebSocketServer .server.WebSocketServer]

解决方式

1. 注释注入ServerEndpointExporter的代码

//    @Bean
//    public ServerEndpointExporter serverEndpointExporter() {
//        return new ServerEndpointExporter();
//    }

借鉴 : 解决Multiple Endpoints may not be deployed to the same path — https://blog.csdn.net/weixin_42323802/article/details/86528844

你可能感兴趣的:(Spring,消息推送)