Java网络Socket编程-websocket

实现一个用于监测 WebSocket 连接状态的线程类，其作用是通过创建一个 WebSocket 客户端，连接到指定的 WebSocket 地址，并监测连接的状态。

代码中的 WebSocketThread 类继承自 Thread，意味着它可以在单独的线程中执行。该线程类使用 Tyrus 提供的 @ClientEndpoint 注解来标识这是一个 WebSocket 客户端端点。

在代码中，通过定义 @OnOpen、@OnMessage、@OnClose 和 @OnError 注解的方法，来处理与 WebSocket 连接相关的事件。例如，在 onOpen 方法中，当连接成功建立时，会将 session 对象赋值，并重置重连次数。

通过调用 connect 方法，可以创建一个 WebSocket 客户端，并连接到指定的 WebSocket 地址。在连接过程中，会触发 @OnOpen 注解的方法。

在 run 方法中，循环执行连接和断开连接的操作。在每次连接成功后，使用一个内部循环来定时检查连接状态。如果超过设定的连接超时时间 connectTimeout，仍未收到消息或心跳，则认为连接已关闭，更新监控 WebSocket 的状态为 "CLOSE"。如果在超时时间内收到了消息或心跳，更新监控 WebSocket 的状态为 "OPEN"。

通过调用 close 方法，可以关闭 WebSocket 连接，并更新监控 WebSocket 的状态为 "CLOSE"。

代码中的 running 变量用于控制线程的运行状态，当调用 stopThread 方法时，将设置 running 为 false，从而终止线程的执行。

此线程在连接断开后会尝试重新连接，并通过计数器 reconnectTimes 控制重连次数和心跳间隔。在每次重连时，会等待一段时间后再次尝试连接。每次重连后都会检查连接状态并更新监控 WebSocket 的状态。

请注意，该代码片段中使用了一些自定义的类和接口，例如 IMonWebsocketService，这些类和接口在代码中没有给出具体实现。因此，要使代码正常运行，需要确保相关的类和接口已经正确实现，并且适配于你的应用程序环境

import org.glassfish.tyrus.client.ClientManager;

import javax.websocket.*;
import java.net.URI;
@ClientEndpoint
public class WebSocketThread extends Thread{


    private Session session;


    private volatile boolean running = true;



    private Long websocketId;
    private String websocketUrl;
    private Integer connectTimeout; // 重连延迟，单位：毫秒
    private String msg;

    private IMonWebsocketService monWebsocketService;

    private String status = "";

    private volatile Integer reconnectTimes = 0;


    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        //System.out.println("WebSocket 连接已打开");
        reconnectTimes = 0;
    }

    @OnMessage
    public void onMessage(String message) {
        //System.out.println("接收到消息: " + message);
        if(StringUtils.isBlank(msg)||"#".equals(msg)){
            reconnectTimes = 0;
        }else{
            if(StringUtils.isNotBlank(message)&&message.equals(msg)){
                reconnectTimes = 0;
            }
        }
    }

    @OnClose
    public void onClose() {
        //System.out.println("WebSocket 连接已关闭");
//        latch.countDown();
        closeStatus();
    }

    @OnError
    public void onError(Throwable error) {
        //System.out.println("WebSocket 错误: " + error.getMessage());
//        latch.countDown();
        closeStatus();
    }

    public void connect(String websocketUrl) {
        ClientManager client = ClientManager.createClient();
//        latch = new CountDownLatch(1);
        try {
            client.connectToServer(this, new URI(websocketUrl));
//            latch.await(); // 等待 WebSocket 连接建立完成
        } catch (Exception e) {
            //System.out.println("无法连接到 WebSocket 服务器: " + e.getMessage());
            closeStatus();
        }
    }

    public void close() {
        closeStatus();
        try {
            session.close();
        } catch (Exception e) {
            //System.out.println("无法关闭 WebSocket 连接: " + e.getMessage());
        }finally {
//            latch.countDown();
        }
    }


//    private CountDownLatch latch = new CountDownLatch(1);


    private void closeStatus(){
        if(!"close".equals(status)) {
            //System.out.println("close-update base");
            monWebsocketService.updateMonWebsocketStatus(websocketId, Status.CLOSE);
            status = "close";
            reconnectTimes = connectTimeout/1000 + 1;
        }
    }



    public WebSocketThread(Long websocketId, String websocketUrl, Integer connectTimeout, String msg, IMonWebsocketService monWebsocketService){
        this.websocketId = websocketId;
        this.websocketUrl = websocketUrl;
        this.connectTimeout = connectTimeout;
        this.msg = msg;
        this.monWebsocketService = monWebsocketService;
    }

    public void stopThread() {
        running = false;
//        latch.countDown();
    }


    public void run() {
//        String websocketUrl = "ws://127.0.0.1:8000/websocket/message"; // 替换为你要测试的 WebSocket 地址

//        WebSocketClient client = new WebSocketClient();
        while (running) {

            connect(websocketUrl);

            out:while (running){
                try {
                    Thread.sleep(1000);
                    reconnectTimes++;
                        //System.out.println("reconnectTimes*1000:"+reconnectTimes*1000);
                    if(reconnectTimes*1000>connectTimeout){//收到消息的心跳间隔大于设置的时间
                        //System.out.println("close");
                        closeStatus();
                        reconnectTimes --;
                        if (session == null||!session.isOpen()) break out;
                    }else{
                        //System.out.println("open");
                        if(!"open".equals(status)) {
                                //System.out.println("open-update base");
                            monWebsocketService.updateMonWebsocketStatus(websocketId, Status.OPEN);
                            status = "open";
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }


            close();

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }


    }

}