Maven依赖

    <parent>
        <!--SpringBoot父级依赖，标记当前项目为SpringBoot项目-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/>
    </parent>

    <dependencies>
        <!--web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- springboot整合的websocket模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!--json解析-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!--lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
    </dependencies>

结构图

SpringBoot整合WebSocket案例_Spring

代码实现

OneToMany.java

package com.daniel.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author Daniel
 * @Description 客户端给其他客户端群发消息
 **/
@Slf4j//日志
@ServerEndpoint(value = "/oneToMany")//前端通过此URL和后端交互，建立连接
@Component//实例化pojo
public class OneToMany {

    //在线人数
    private static AtomicInteger onlineCount = new AtomicInteger(0);

    //在线客户端
    private static Map<String, Session> clients = new ConcurrentHashMap<>();

    //成功建立连接时
    @OnOpen
    public void onOpen(Session session) {
        //在线人数加1
        onlineCount.incrementAndGet();
        //将连接信息放入客户端
        clients.put(session.getId(), session);
        log.info("新用户{}加入，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //关闭连接时
    @OnClose
    public void onClose(Session session) {
        //在线人数减1
        onlineCount.decrementAndGet();
        clients.remove(session.getId());
        log.info("用户{}退出，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //接收到消息时
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("服务端收到客户端[{}]的消息:{}", session.getId(), message);
        this.sendMessage(message, session);
    }

    //发生错误时
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("----------------发生错误----------------");
        error.printStackTrace();
    }

    //群发消息
    public void sendMessage(String message, Session session) {
        //遍历客户端在线人数
        for (Map.Entry<String, Session> sessionEntry : clients.entrySet()) {
            //拿到消息
            String sessionId = session.getId();
            Session toSession = sessionEntry.getValue();
            //排除自己
            if (!sessionId.equals(toSession.getId())) {
                log.info("服务端转发客户端[{}]的群发消息给客户端[{}]，内容：{}", sessionId, toSession.getId(), message);
                toSession.getAsyncRemote().sendText(message);
            }
        }
    }
}

OneToOne.java

package com.daniel.config;

import com.alibaba.fastjson.JSON;
import com.daniel.model.MyMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author Daniel
 * @Description 客户端与客户端之前相互发送消息
 **/
@Slf4j//日志
@ServerEndpoint(value = "/oneToOne")//前端通过此URL和后端交互，建立连接
@Component//实例化pojo
public class OneToOne {

    //在线人数
    private static AtomicInteger onlineCount = new AtomicInteger(0);

    //在线客户端
    private static Map<String, Session> clients = new ConcurrentHashMap<>();

    //成功建立连接时
    @OnOpen
    public void onOpen(Session session) {
        //在线人数加1
        onlineCount.incrementAndGet();
        //将连接信息放入客户端
        clients.put(session.getId(), session);
        log.info("新用户{}加入，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //关闭连接时
    @OnClose
    public void onClose(Session session) {
        //在线人数减1
        onlineCount.decrementAndGet();
        clients.remove(session.getId());
        log.info("用户{}退出，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //客户端发送过来的消息
    @OnMessage
    public void onMessage(String message, Session session) {
        String sessionId = session.getId();
        String[] messages = message.split(" ");
        //将客户端的消息转换为json字符串
        String json = "{\"message\":\"" + messages[0] + "\", \"userId\":" + messages[1] + "}";
        log.info("服务端收到客户端[{}]的消息[{}]", sessionId, json);
        try {
            MyMessage myMessage = JSON.parseObject(json, MyMessage.class);
            if (myMessage != null) {
                Session toSession = clients.get(myMessage.getUserId());
                if (toSession != null) {
                    this.sendMessage(myMessage.getMessage(), toSession, sessionId);
                }
            }
        } catch (Exception e) {
            log.error("----------------发生错误----------------", e);
        }
    }

    //发生错误时
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("----------------发生错误----------------");
        error.printStackTrace();
    }

    //服务端发送消息给客户端
    public void sendMessage(String message, Session toSession, String sessionId) {
        try {
            log.info("服务端转发客户端[{}]的消息给客户端[{}]，内容：{}", sessionId, toSession.getId(), message);
            toSession.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("----------------发生错误----------------", e);
        }
    }

}

OneWebSocket.java

package com.daniel.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author Daniel
 * @Description 客户端与服务端交互
 **/
@Slf4j//日志
@ServerEndpoint(value = "/oneWebSocket")//前端通过此URL和后端交互，建立连接
@Component
public class OneWebSocket {

    //在线人数
    private static AtomicInteger onlineCount = new AtomicInteger(0);

    //成功建立连接时
    @OnOpen
    public void onOpen(Session session) {
        //在线人数加1
        onlineCount.incrementAndGet();
        //将连接信息放入客户端
        log.info("新用户{}加入，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //关闭连接时
    @OnClose
    public void onClose(Session session) {
        //在线人数减1
        onlineCount.decrementAndGet();
        log.info("用户{}退出，当前在线人数为：{}", session.getId(), onlineCount.get());
    }

    //客户端发送过来的消息
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("服务端收到客户端[{}]的消息:{}", session.getId(), message);
        //给客户端回消息
        this.sendMessage("Hello, " + message, session);
    }

    //发生错误时
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("----------------发生错误----------------");
        error.printStackTrace();
    }

    //回消息
    public void sendMessage(String message, Session toSession) {
        try {
            log.info("服务端给客户端[{}]发送消息，内容：{}", toSession.getId(), message);
            toSession.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("----------------发生错误----------------", e);
        }
    }
}

WebSocketConfiguration.java

package com.daniel.config;

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

/**
 * @Author Daniel
 * @Description WebSocket配置类
 **/
@Configuration
public class WebSocketConfiguration {

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

}

MyMessage.java

package com.daniel.model;

import lombok.Data;

/**
 * @Author Daniel
 * @Description pojo
 **/
@Data
public class MyMessage {
    private String userId;
    private String message;

}

Application.java

package com.daniel;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author Daniel
 * @Description SpringBoot启动类
 **/
@SpringBootApplication//
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

index.html

<!DOCTYPE HTML>
<html>
<head>
    <title>My WebSocket</title>
</head>

<body>
<input id="text" type="text"/>
<button onclick="send()">Send</button>
<button onclick="close()">Close</button>
<div id="message"></div>
</body>

<script type="text/javascript">
    var websocket = null;

    //判断当前浏览器是否支持WebSocket
    if ('WebSocket' in window) {
        websocket = new WebSocket("ws://localhost:8080/oneWebSocket");//此处地址在分情况测试的时候需要修改
    } else {
        alert('Not support websocket')
    }

    //发生错误时
    websocket.onerror = function () {
        setMessageInnerHTML("error");
    };

    //成功建立连接时
    websocket.onopen = function (event) {
        //setMessageInnerHTML("open");
    }

    //接收到消息时
    websocket.onmessage = function (event) {
        setMessageInnerHTML(event.data);
    }

    //关闭连接时
    websocket.onclose = function () {
        setMessageInnerHTML("close");
    }

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

    //显示服务器端返回的消息
    function setMessageInnerHTML(innerHTML) {
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //关闭连接按钮
    function close() {
        websocket.close();
    }

    //发送消息按钮
    function send() {
        var message = document.getElementById('text').value;
        websocket.send(message);
    }
</script>
</html>

大写的注意：这里一定要调用websocket.send()方法，不然无法与后台产生交互!!!

启动与测试

1.客户端与服务端交互

修改index.html页面中第19行代码

websocket = new WebSocket("ws://localhost:8080/oneWebSocket");

启动Application

http://localhost:8080/

可以看到log

SpringBoot整合WebSocket案例_Spring_02

发送消息

SpringBoot整合WebSocket案例_websocket_03

可以在log中看到前后端产生了交互

SpringBoot整合WebSocket案例_springboot_04

2.一个客户端与另一个客户端之间交互

修改index.html页面中第19行代码

websocket = new WebSocket("ws://localhost:8080/oneToOne");

启动之后，打开多个客户端，可以看到log

SpringBoot整合WebSocket案例_websocket_05

使用“消息 被接受人”的格式给其他客户端发消息

Hello 1
早啊 2

SpringBoot整合WebSocket案例_websocket_06

3.群发消息

修改index.html页面中第19行代码

websocket = new WebSocket("ws://localhost:8080/oneToMany");

SpringBoot整合WebSocket案例_Spring_07

启动之后，打开多个客户端，发送群发消息

SpringBoot整合WebSocket案例_Spring_08

log:

在这里插入图片描述