springboot使用websocket推送消息(tomcat)

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

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

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.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@ServerEndpoint(value = "/socketServer/{userId}")
@Component
public class SocketServer {

    private Session session;
    private static ConcurrentHashMap<String, Session> sessionPool = new ConcurrentHashMap<>();
    private static ConcurrentHashMap<String, String> sessionIds = new ConcurrentHashMap<>();

    /**
     * 用户连接时触发
     *
     * @param session
     * @param userId
     */
    @OnOpen
    public void open(Session session, @PathParam(value = "userId") String userId) {
        this.session = session;
        sessionPool.put(userId, session);
        sessionIds.put(session.getId(), userId);
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message
     */
    @OnMessage
    public void onMessage(String message) {
        sendMessage(sessionIds.get(session.getId()) + "<--" + message, "99");
    }

    /**
     * 连接关闭触发
     */
    @OnClose
    public void onClose() {
        sessionPool.remove(sessionIds.get(session.getId()));
        sessionIds.remove(session.getId());
    }

    /**
     * 发生错误时触发
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        error.printStackTrace();
    }

    /**
     * 信息发送的方法
     *
     * @param message
     * @param userId
     */
    public static void sendMessage(Object message, String userId) {
        Session session = sessionPool.get(userId);
        if (session != null) {
            try {
                session.getBasicRemote().sendObject(message);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (EncodeException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取当前连接数
     *
     * @return
     */
    public static int getOnlineNum() {
        if (sessionIds.values().contains("99")) {
            return sessionPool.size() - 1;
        }
        return sessionPool.size();
    }

    /**
     * 获取在线用户名以逗号隔开
     *
     * @return
     */
    public static String getOnlineUsers() {
        StringBuffer users = new StringBuffer();
        for (String key : sessionIds.keySet()) {//99是服务端自己的连接，不能算在线人数
            if (!"99".equals(sessionIds.get(key))) {
                users.append(sessionIds.get(key) + ",");
            }
        }
        return users.toString();
    }

    /**
     * 信息群发
     *
     * @param msg
     */
    public static void sendAll(String msg) {
        for (String key : sessionIds.keySet()) {
            if (!"99".equals(sessionIds.get(key))) {
                sendMessage(msg, sessionIds.get(key));
            }
        }
    }

    /**
     * 多个人发送给指定的几个用户
     *
     * @param msg
     * @param userIds 用户s
     */

    public static void SendMany(String msg, String[] userIds) {
        for (String userId : userIds) {
            sendMessage(msg, userId);
        }
    }
}

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * websocket
 * 消息推送(个人和广播)
 */
@Controller
@RequestMapping("/webSocket")
public class WebSocketController {

    /**
     * 个人信息推送
     *
     * @return
     */
    @RequestMapping("/sendToSingle")
    @ResponseBody
    public String sendToSingle(String msg, String userId) {
        SocketServer.sendMessage(msg, userId);
        return "success";
    }

    /**
     * 多人信息推送
     *
     * @return
     */
    @RequestMapping("/sendToMany")
    @ResponseBody
    public String sendToMany(String msg, String userIds) {
        String[] persons = userIds.split(",");
        SocketServer.SendMany(msg, persons);
        return "success";
    }

    /**
     * 推送给所有在线用户
     *
     * @return
     */
    @RequestMapping("/sendToAll")
    @ResponseBody
    public String sendToAll(String msg) {
        SocketServer.sendAll(msg);
        return "success";
    }

    /**
     * 获取当前在线用户
     *
     * @return
     */
    @RequestMapping("/webStatus")
    public String webStatus() {
        //当前用户个数
        int count = SocketServer.getOnlineNum();
        //当前在线所有用户
        String names = SocketServer.getOnlineUsers();
        return count + names;
    }
}

var websocket = null;
var userId = localStorage.getItem("userId ");

//判断当前浏览器是否支持WebSocket
if ('WebSocket' in window) {
websocket = new WebSocket("ws://localhost:8090/项目名/socketServer"+ userId);
} else {
    alert('当前浏览器 Not support websocket')
}

//连接发生错误的回调方法
websocket.onerror = function() {
    setMessageInnerHTML("WebSocket连接发生错误");
};

//连接成功建立的回调方法
websocket.onopen = function() {
    setMessageInnerHTML("WebSocket连接成功");
}

//接收到消息的回调方法
websocket.onmessage = function(event) {
    setMessageInnerHTML(event.data);
}

//连接关闭的回调方法
websocket.onclose = function() {
    setMessageInnerHTML("WebSocket连接关闭");
}

//监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
window.onbeforeunload = function() {
    closeWebSocket();
}

//关闭WebSocket连接
function closeWebSocket() {
    websocket.close();
}