<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 {

//打成war包部署在tomcat中的話不需要這個bean
    @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();
}