正确主动关闭websocket，异常关闭处理

CloseEvent.code

下面是一个示例的WebSocket错误码表格，包括错误码、错误处理方法和错误码说明：

• 0-999 暂未使用

---

后面的不想翻译，请读者自行翻译，帮你贴一个翻译传送门

关闭监听

TS

WebSocket.onclose = (event) => {
  console.log(event.code);
};
1
2
3

java

    @Override
    public void onClosed(WebSocket webSocket, int code, String reason) {
        super.onClosed(webSocket, code, reason);
        // todo 根据状态码执行重连
        if(code != 1000){
        
        }
    }
1
2
3
4
5
6
7
8

JavaScript (Node.js)：

const WebSocket = require('ws');

const ws = new WebSocket('ws://localhost:8080');

ws.on('open', () => {
  // WebSocket连接成功
});

ws.on('message', (data) => {
  // 处理接收到的消息
});

ws.on('close', () => {
  // WebSocket连接关闭
});

ws.on('error', (error) => {
  // 处理WebSocket错误
  ws.close();

  // 执行重连逻辑
  setTimeout(() => {
    const newWs = new WebSocket('ws://localhost:8080');
    // ...
  }, 5000);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Python：

import websocket

def on_message(ws, message):
    # 处理接收到的消息

def on_close(ws):
    # WebSocket连接关闭

def on_error(ws, error):
    # 处理WebSocket错误
    ws.close()

    # 执行重连逻辑
    time.sleep(5)
    new_ws = websocket.WebSocketApp("ws://localhost:8080", on_open=on_open, on_message=on_message, on_close=on_close, on_error=on_error)
    # ...

def on_open(ws):
    # WebSocket连接成功

ws = websocket.WebSocketApp("ws://localhost:8080", on_open=on_open, on_message=on_message, on_close=on_close, on_error=on_error)
ws.run_forever()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Java Android：

import javax.websocket.*;

@ClientEndpoint
public class WebSocketClient {
    @OnOpen
    public void onOpen(Session session) {
        // WebSocket连接成功
    }

    @OnMessage
    public void onMessage(String message) {
        // 处理接收到的消息
    }

    @OnClose
    public void onClose(Session session, CloseReason closeReason) {
        // WebSocket连接关闭
    }

    @OnError
    public void onError(Session session, Throwable error) {
        // 处理WebSocket错误
        try {
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 执行重连逻辑
        try {
            Thread.sleep(5000);
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            Session newSession = container.connectToServer(WebSocketClient.class, URI.create("ws://localhost:8080"));
            // ...
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

###. C#：

using System;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketClient {
    private ClientWebSocket _client;

    public async Task Connect() {
        _client = new ClientWebSocket();
        await _client.ConnectAsync(new Uri("ws://localhost:8080"), CancellationToken.None);

        // WebSocket连接成功

        // 接收消息
        while (_client.State == WebSocketState.Open) {
            var buffer = new ArraySegment<byte>(new byte[4096]);
            WebSocketReceiveResult result = await _client.ReceiveAsync(buffer, CancellationToken.None);

            if (result.MessageType == WebSocketMessageType.Text) {
                string message = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, result.Count);
                // 处理接收到的消息
            }
        }
    }

    public async Task Close() {
        await _client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);

        // WebSocket连接关闭

        // 执行重连逻辑
        await Task.Delay(5000);
        await Connect();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

以下是使用Kotlin和Swift语言实现关闭WebSocket并根据异常执行重连的示例：

Kotlin:

import okhttp3.*
import okhttp3.WebSocket
import okhttp3.WebSocketListener
import java.util.concurrent.TimeUnit

class WebSocketClient : WebSocketListener() {
    private lateinit var webSocket: WebSocket

    fun connect() {
        val okHttpClient = OkHttpClient.Builder()
            .retryOnConnectionFailure(true)
            .pingInterval(10, TimeUnit.SECONDS)
            .build()

        val request = Request.Builder()
            .url("ws://localhost:8080")
            .build()

        webSocket = okHttpClient.newWebSocket(request, this)
    }

    override fun onOpen(webSocket: WebSocket, response: Response) {
        // WebSocket连接成功
    }

    override fun onMessage(webSocket: WebSocket, text: String) {
        // 处理接收到的消息
    }

    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
        // WebSocket连接关闭
    }

    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
        // 处理WebSocket错误
        webSocket.close(1000, null)

        // 执行重连逻辑
        Thread.sleep(5000)
        connect()
    }
}

fun main() {
    val client = WebSocketClient()
    client.connect()
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

Swift:

import Foundation
import Starscream

class WebSocketClient: WebSocketDelegate {
    private var socket: WebSocket?

    func connect() {
        socket = WebSocket(url: URL(string: "ws://localhost:8080")!)
        socket?.delegate = self
        socket?.connect()
    }

    func websocketDidConnect(socket: WebSocketClient) {
        // WebSocket连接成功
    }

    func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
        // 处理接收到的消息
    }

    func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
        // WebSocket连接关闭

        // 执行重连逻辑
        DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
            self.connect()
        }
    }

    func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
        // 处理接收到的数据
    }
}

let client = WebSocketClient()
client.connect()
// ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37