SpringBoot集成WebSocket实现服务端和客户端消息的收发

原创已于 2025-09-03 09:31:34 修改 · 712 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#java #spring boot #websocket

于 2024-10-16 14:08:09 首次发布

杂乱无章专栏收录该内容

24 篇文章

订阅专栏

文章目录

概要

SpringBoot项目集成WebSocket，完成server端和client端连接，消息的收发。

服务端

环境

Jar包依赖：

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

代码实现

定义WebSocketServerConfig配置类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;  
import org.springframework.web.socket.server.standard.ServerEndpointExporter;  
  
@Configuration  
public class WebSocketServerConfig {
  
    @Bean  
    public ServerEndpointExporter serverEndpointExporter() {  
        return new ServerEndpointExporter();  
    }  
}

定义WebSocketServer服务，使用 @ServerEndpoint 注解表示此类是一个 WebSocket 端点。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @auther yuyanze
 * @create 2024-10-15-14:58
 * @description 使用 @ServerEndpoint 注解表示此类是一个 WebSocket 端点
 * 通过 value 注解，指定 websocket 的路径
 */
@Component
@ServerEndpoint(value = "/websocket")
public class WebSocketServer {

    private static final Logger logger = LoggerFactory.getLogger(WebSocketServer.class);

    private Session session;

    // 记录连接的客户端
    private static ConcurrentHashMap<String, Session> clients = new ConcurrentHashMap<>();

    @OnOpen
    public void onOpen(Session session) {
        // 连接打开时，将session添加到clients中
        clients.put(session.getId(), session);
        logger.info("连接打开: {}", session.getId());
    }

    @OnClose
    public void onClose(Session session) {
        // 连接关闭时，从clients中移除session
        clients.remove(session.getId());
        logger.info("连接关闭: {}", session.getId());
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        // 接收消息时，可以处理消息并回复
        logger.info("收到消息: " + message + " from " + session.getId());
        try {
            session.getBasicRemote().sendText("收到消息: " + message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        // 发生错误时，可以记录日志或进行其他处理
        logger.error("发生错误: " + throwable.getMessage());
    }

    // 发送消息给所有连接的客户端
    public static void sendMessageToAll(String message) {
        for (Session session : clients.values()) {
            try {
                session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

启动服务，客户端连接websocket，发送消息。
在这里插入图片描述
服务端接收消息

客户端

环境

Jar包依赖：

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-websocket</artifactId>
 </dependency>
 <dependency>
     <groupId>org.java-websocket</groupId>
     <artifactId>Java-WebSocket</artifactId>
     <version>1.4.0</version>
 </dependency>

代码实现

方式1：创建JavaClient类

import lombok.extern.slf4j.Slf4j;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft_6455;
import org.java_websocket.handshake.ServerHandshake;
import org.springframework.stereotype.Component;

import java.net.URI;
import java.net.URISyntaxException;

@Slf4j
@Component
public class JavaClient {

    /**
     * 获取客户端连接实例
     *
     * @param uri
     * @return
     */
    public WebSocketClient getClient(String uri) {

        try {
            //创建客户端连接对象
            WebSocketClient client = new WebSocketClient(new URI(uri), new Draft_6455()) {
                /**
                 * 建立连接调用
                 * @param serverHandshake
                 */
                @Override
                public void onOpen(ServerHandshake serverHandshake) {
                    log.info("建立连接");
                }

                /**
                 * 收到服务端消息调用
                 * @param s
                 */
                @Override
                public void onMessage(String s) {
                    log.info("收到来自服务端的消息-->" + s);
                }

                /**
                 * 断开连接调用
                 * @param i
                 * @param s
                 * @param b
                 */
                @Override
                public void onClose(int i, String s, boolean b) {
                    log.info("关闭连接-->" + "i = " + i + "-->s = " + s + "-->b = " + b);
                }

                /**
                 * 连接报错调用
                 * @param e
                 */
                @Override
                public void onError(Exception e) {
                    log.error("报错了-->" + e.getMessage());
                }
            };

            //请求与服务端建立连接
            client.connect();
            //判断连接状态，0为请求中  1为已建立  其它值都是建立失败
            while (client.getReadyState().ordinal() == 0) {
                try {
                    Thread.sleep(200);
                } catch (Exception e) {
                    log.warn("延迟操作出现问题，但并不影响功能");
                }
                log.info("连接中……");
            }

            //连接状态不再是0请求中，判断建立结果是不是1已建立
            if (client.getReadyState().ordinal() == 1) {
                return client;
            }
        } catch (URISyntaxException e) {
            log.error(e.getMessage());
        }
        return null;
    }

    public static void main(String[] args) {
        JavaClient javaClient = new JavaClient();
        WebSocketClient client = javaClient.getClient("wss://xxxx");
        if (null != client) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            client.send("xxx");
        }
    }

方式2：使用SpringBoot实现
定义WebSocketConfig配置类。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
 
@Configuration
public class WebSocketConfig {
    @Bean
    public WebSocketClient webSocketClient() {
        return new StandardWebSocketClient();
    }
}

定义WebSocketService实现类。

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson2.JSON;
import org.example.websocket.client.springWebSocket.domain.RealTimeDataVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.WebSocketConnectionManager;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import java.util.Map;

/**
 * @author yuyanze
 * @create 2024-10-15-15:42
 * @description
 */
@Component
public class WebSocketService extends TextWebSocketHandler {

    private WebSocketSession session;

    @Autowired
    private WebSocketClient client;

    public void connect(String uri) {
        WebSocketConnectionManager manager = new WebSocketConnectionManager(client, this, uri);
        manager.start();
    }

    public void disconnect() throws Exception {
        if (session != null && session.isOpen()) {
            session.close();
        }
    }

    public void sendMessage(String message) throws Exception {
        if (session != null && session.isOpen()) {
            session.sendMessage(new TextMessage(message));
        } else {
            throw new IllegalStateException("WebSocket is not connected.");
        }
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        this.session = session;
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        System.out.println("Received: " + message.getPayload());
    }
}