Android WebSocket工具类：重连、心跳、消息队列一站式办理方案

• 依赖库
  使用 OkHttp 的WebSocket支持。
  

在 build.gradle 中添加依赖：

1. implementation 'com.squareup.okhttp3:okhttp:4.9.3'

复制代码

• WebSocket工具类实现
  

1. import okhttp3.*;
2. import android.os.Handler;
3. import android.os.Looper;
4. import android.util.Log;
6. import java.util.concurrent.ConcurrentLinkedQueue;
7. import java.util.concurrent.ExecutorService;
8. import java.util.concurrent.Executors;
9. import java.util.concurrent.TimeUnit;
10. import java.util.concurrent.atomic.AtomicInteger;
12. public class WebSocketManager {
13.     private static final String TAG = "WebSocketManager";
15.     private OkHttpClient client;
16.     private WebSocket webSocket;
17.     private String wsUrl;
18.     private AtomicInteger reconnectCount = new AtomicInteger(0);
19.     private boolean isConnecting = false;
20.     private boolean isConnected = false;
21.     private Handler mainHandler = new Handler(Looper.getMainLooper());
22.     private Runnable heartbeatRunnable;
23.     private ConcurrentLinkedQueue<String> messageQueue = new ConcurrentLinkedQueue<>(); // 线程安全的消息队列
24.     private ExecutorService executorService = Executors.newSingleThreadExecutor(); // 线程池
26.     private int maxReconnectCount = 5; // 最大重连次数
27.     private long reconnectInterval = 5000; // 重连间隔时间（毫秒）
28.     private long heartbeatInterval = 30000; // 心跳间隔时间（毫秒）
29.     private long heartbeatTimeout = 60000; // 心跳超时时间（毫秒）
31.     private WebSocketCallback callback;
33.     private WebSocketListener webSocketListener = new WebSocketListener() {
34.         @Override
35.         public void onOpen(WebSocket webSocket, Response response) {
36.             Log.d(TAG, "WebSocket connected");
37.             isConnecting = false;
38.             isConnected = true;
39.             reconnectCount.set(0); // 重置重连次数
40.             startHeartbeat(); // 开始心跳
41.             sendQueuedMessages(); // 发送缓存的消息
42.             if (callback != null) {
43.                 mainHandler.post(() -> callback.onConnected());
44.             }
45.         }
47.         @Override
48.         public void onMessage(WebSocket webSocket, String text) {
49.             Log.d(TAG, "Received message: " + text);
50.             if (callback != null) {
51.                 mainHandler.post(() -> callback.onMessage(text));
52.             }
53.         }
55.         @Override
56.         public void onClosed(WebSocket webSocket, int code, String reason) {
57.             Log.d(TAG, "WebSocket closed: " + reason);
58.             isConnecting = false;
59.             isConnected = false;
60.             stopHeartbeat(); // 停止心跳
61.             if (callback != null) {
62.                 mainHandler.post(() -> callback.onDisconnected());
63.             }
64.         }
66.         @Override
67.         public void onFailure(WebSocket webSocket, Throwable t, Response response) {
68.             Log.e(TAG, "WebSocket failed: " + t.getMessage());
69.             isConnecting = false;
70.             isConnected = false;
71.             stopHeartbeat(); // 停止心跳
72.             if (callback != null) {
73.                 mainHandler.post(() -> callback.onError(t));
74.             }
75.             reconnect(); // 尝试重连
76.         }
77.     };
79.     // 私有构造函数，使用Builder模式创建实例
80.     private WebSocketManager(Builder builder) {
81.         this.wsUrl = builder.wsUrl;
82.         this.maxReconnectCount = builder.maxReconnectCount;
83.         this.reconnectInterval = builder.reconnectInterval;
84.         this.heartbeatInterval = builder.heartbeatInterval;
85.         this.heartbeatTimeout = builder.heartbeatTimeout;
87.         client = new OkHttpClient.Builder()
88.                 .connectTimeout(10, TimeUnit.SECONDS)
89.                 .writeTimeout(10, TimeUnit.SECONDS)
90.                 .readTimeout(10, TimeUnit.SECONDS)
91.                 .build();
92.     }
94.     // 连接WebSocket
95.     public void connect() {
96.         if (!isConnecting && !isConnected) {
97.             isConnecting = true;
98.             executorService.submit(() -> {
99.                 Request request = new Request.Builder().url(wsUrl).build();
100.                 webSocket = client.newWebSocket(request, webSocketListener);
101.             });
102.         }
103.     }
105.     // 断开连接
106.     public void disconnect() {
107.         if (webSocket != null) {
108.             executorService.submit(() -> webSocket.close(1000, "Normal closure"));
109.         }
110.         releaseResources();
111.     }
113.     // 发送消息
114.     public void sendMessage(String message) {
115.         if (webSocket != null && isConnected) {
116.             executorService.submit(() -> {
117.                 boolean sent = webSocket.send(message);
118.                 if (!sent) {
119.                     // 发送失败，将消息加入队列
120.                     messageQueue.offer(message);
121.                 }
122.             });
123.         } else {
124.             // 网络未连接时，将消息加入队列
125.             messageQueue.offer(message);
126.         }
127.     }
129.     // 重连机制
130.     private void reconnect() {
131.         if (reconnectCount.get() < maxReconnectCount) {
132.             reconnectCount.incrementAndGet();
133.             mainHandler.postDelayed(() -> {
134.                 Log.d(TAG, "Reconnecting... Attempt: " + reconnectCount.get());
135.                 connect();
136.             }, reconnectInterval);
137.         } else {
138.             Log.e(TAG, "Max reconnection attempts reached");
139.         }
140.     }
142.     // 发送缓存的消息
143.     private void sendQueuedMessages() {
144.         executorService.submit(() -> {
145.             while (!messageQueue.isEmpty()) {
146.                 String message = messageQueue.poll();
147.                 if (message != null) {
148.                     boolean sent = webSocket.send(message);
149.                     if (!sent) {
150.                         // 发送失败，将消息重新加入队列
151.                         messageQueue.offer(message);
152.                         break;
153.                     }
154.                 }
155.             }
156.         });
157.     }
159.     // 开始心跳
160.     private void startHeartbeat() {
161.         heartbeatRunnable = new Runnable() {
162.             @Override
163.             public void run() {
164.                 if (isConnected) {
165.                     webSocket.send("Heartbeat"); // 发送心跳消息
166.                     mainHandler.postDelayed(this, heartbeatInterval);
167.                 }
168.             }
169.         };
170.         mainHandler.post(heartbeatRunnable);
171.     }
173.     // 停止心跳
174.     private void stopHeartbeat() {
175.         mainHandler.removeCallbacks(heartbeatRunnable);
176.     }
178.     // 释放资源
179.     private void releaseResources() {
180.         executorService.shutdown();
181.         mainHandler.removeCallbacksAndMessages(null);
182.     }
184.     // 设置回调
185.     public void setWebSocketCallback(WebSocketCallback callback) {
186.         this.callback = callback;
187.     }
189.     // Builder模式
190.     public static class Builder {
191.         private String wsUrl;
192.         private int maxReconnectCount = 5;
193.         private long reconnectInterval = 5000;
194.         private long heartbeatInterval = 30000;
195.         private long heartbeatTimeout = 60000;
197.         public Builder(String wsUrl) {
198.             this.wsUrl = wsUrl;
199.         }
201.         public Builder setMaxReconnectCount(int maxReconnectCount) {
202.             this.maxReconnectCount = maxReconnectCount;
203.             return this;
204.         }
206.         public Builder setReconnectInterval(long reconnectInterval) {
207.             this.reconnectInterval = reconnectInterval;
208.             return this;
209.         }
211.         public Builder setHeartbeatInterval(long heartbeatInterval) {
212.             this.heartbeatInterval = heartbeatInterval;
213.             return this;
214.         }
216.         public Builder setHeartbeatTimeout(long heartbeatTimeout) {
217.             this.heartbeatTimeout = heartbeatTimeout;
218.             return this;
219.         }
221.         public WebSocketManager build() {
222.             return new WebSocketManager(this);
223.         }
224.     }
226.     // 回调接口
227.     public interface WebSocketCallback {
228.         void onMessage(String message);
229.         void onConnected();
230.         void onDisconnected();
231.         void onError(Throwable t);
232.     }
233. }

复制代码

• 功能阐明
  3.1 毗连状态管理
  增长 isConnecting 状态，区分毗连中和已毗连状态。
  

3.2 消息重发机制
在发送失败时，将消息重新参加队列，等待重连后发送。
3.3 动态心跳机制
支持动态调解心跳隔断和超时时间。
3.4 资源开释
在断开毗连时，开释线程池和Handler资源，制止内存走漏。
3.5 日志分级
通过 Log.d 和 Log.e 区分调试日志和错误日志。

• 使用示例
  4.1 初始化并毗连WebSocket
  

1. WebSocketManager webSocketManager = new WebSocketManager.Builder("ws://your-websocket-url")
2.         .setMaxReconnectCount(10)
3.         .setReconnectInterval(3000)
4.         .setHeartbeatInterval(60000)
5.         .setHeartbeatTimeout(120000)
6.         .build();
8. webSocketManager.setWebSocketCallback(new WebSocketManager.WebSocketCallback() {
9.     @Override
10.     public void onMessage(String message) {
11.         Log.d(TAG, "Received: " + message);
12.     }
14.     @Override
15.     public void onConnected() {
16.         Log.d(TAG, "Connected");
17.     }
19.     @Override
20.     public void onDisconnected() {
21.         Log.d(TAG, "Disconnected");
22.     }
24.     @Override
25.     public void onError(Throwable t) {
26.         Log.e(TAG, "Error: " + t.getMessage());
27.     }
28. });
30. webSocketManager.connect();

复制代码

4.2 发送消息

1. webSocketManager.sendMessage("Hello, WebSocket!");

复制代码

4.3 断开毗连

1. webSocketManager.disconnect();

复制代码

4.4 处置惩罚生命周期

1. @Overrideprotected void onDestroy() {    super.onDestroy();    webSocketManager.disconnect();
2. }

复制代码

在Activity中使用WebSocket工具类非常简单。我们须要确保WebSocket的生命周期与Activity的生命周期绑定，制止内存走漏和资源浪费。以下是完备的示例代码，展示如安在Activity中初始化、使用和开释WebSocket工具类。
在Activity中使用WebSocket工具类

• Activity代码示例
  

1. import android.os.Bundle;import android.util.Log;import androidx.annotation.Nullable;import androidx.appcompat.app.AppCompatActivity;public class MainActivity extends AppCompatActivity {    private static final String TAG = "MainActivity";    private WebSocketManager webSocketManager;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        // 初始化WebSocketManager        webSocketManager = new WebSocketManager.Builder("ws://your-websocket-url")                .setMaxReconnectCount(10)                .setReconnectInterval(3000)                .setHeartbeatInterval(60000)                .setHeartbeatTimeout(120000)                .build();        // 设置WebSocket回调        webSocketManager.setWebSocketCallback(new WebSocketManager.WebSocketCallback() {            @Override            public void onMessage(String message) {                Log.d(TAG, "Received: " + message);                // 在这里处置惩罚汲取到的消息            }            @Override            public void onConnected() {                Log.d(TAG, "Connected");                // 在这里处置惩罚毗连乐成变乱            }            @Override            public void onDisconnected() {                Log.d(TAG, "Disconnected");                // 在这里处置惩罚毗连断开变乱            }            @Override            public void onError(Throwable t) {                Log.e(TAG, "Error: " + t.getMessage());                // 在这里处置惩罚错误变乱            }        });        // 毗连WebSocket        webSocketManager.connect();
2.         // 发送消息        webSocketManager.sendMessage("Hello, WebSocket!");
4.     }    @Override    protected void onDestroy() {        super.onDestroy();        // 断开WebSocket毗连并开释资源        if (webSocketManager != null) {            webSocketManager.disconnect();
5.         }    }}

复制代码

• 代码阐明
  2.1 初始化WebSocketManager
  在 onCreate 方法中，使用 Builder 模式初始化 WebSocketManager，并设置最大重连次数、重连隔断、心跳隔断和超时时间。
  

1. webSocketManager = new WebSocketManager.Builder("ws://your-websocket-url")
2.         .setMaxReconnectCount(10)
3.         .setReconnectInterval(3000)
4.         .setHeartbeatInterval(60000)
5.         .setHeartbeatTimeout(120000)
6.         .build();

复制代码

2.2 设置回调
通过 setWebSocketCallback 方法设置回调接口，处置惩罚WebSocket的毗连、消息、断开和错误变乱。

1. webSocketManager.setWebSocketCallback(new WebSocketManager.WebSocketCallback() {
2.     @Override
3.     public void onMessage(String message) {
4.         Log.d(TAG, "Received: " + message);
5.         // 在这里处理接收到的消息
6.     }
8.     @Override
9.     public void onConnected() {
10.         Log.d(TAG, "Connected");
11.         // 在这里处理连接成功事件
12.     }
14.     @Override
15.     public void onDisconnected() {
16.         Log.d(TAG, "Disconnected");
17.         // 在这里处理连接断开事件
18.     }
20.     @Override
21.     public void onError(Throwable t) {
22.         Log.e(TAG, "Error: " + t.getMessage());
23.         // 在这里处理错误事件
24.     }
25. });

复制代码

2.3 毗连WebSocket
在 onCreate 方法中调用 connect() 方法，启动WebSocket毗连。

1. webSocketManager.connect();

复制代码

2.4 发送消息
通过 sendMessage 方法发送消息。

1. webSocketManager.sendMessage("Hello, WebSocket!");

复制代码

2.5 开释资源
在 onDestroy 方法中调用 disconnect() 方法，断开WebSocket毗连并开释资源。

1. @Overrideprotected void onDestroy() {    super.onDestroy();    if (webSocketManager != null) {        webSocketManager.disconnect();
2.     }}

复制代码

• 注意事项
  3.1 生命周期绑定
  确保WebSocket的生命周期与Activity的生命周期绑定，制止内存走漏。
  

在 onDestroy 中开释资源。
3.2 线程安全
WebSocket的回调方法（如 onMessage）运行在配景线程，如果须要更新UI，请使用 Handler 或 runOnUiThread。
3.3 网络权限
在 AndroidManifest.xml 中添加网络权限：

1. <!--    网络权限-->
2.     <uses-permission android:name="android.permission.INTERNET"/>
3. <!--    wifi权限-->
4.     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
5.     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
6.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
7.     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>

复制代码

3.4 SSL/TLS支持
如果WebSocket服务器使用 wss 协议（即基于SSL/TLS的安全毗连），OkHttp 会自动处置惩罚SSL/TLS握手，无需额外设置。

• 扩展功能
  4.1 动态调解心跳隔断
  可以根据服务器相应动态调解心跳隔断。比方，在收到服务器的心跳相应后，延伸心跳隔断。
  

1. @Override
2. public void onMessage(String message) {
3.     if ("HeartbeatResponse".equals(message)) {
4.         // 动态调整心跳间隔
5.         webSocketManager.setHeartbeatInterval(120000);
6.     }
7. }

复制代码

4.2 消息重发机制
在发送失败时，将消息参加队列，等待重连后重新发送。

1. webSocketManager.sendMessage("Hello, WebSocket!");

复制代码

4.3 日志分级
通过 Log.d 和 Log.e 区分调试日志和错误日志，方便调试和生产环境使用。

• 总结
  在Activity中使用优化后的WebSocket工具类非常简单。通过生命周期绑定、回调接口和资源开释机制，可以确保WebSocket的高效运行和资源管理。以下是完备的流程：
  

初始化：在 onCreate 中初始化 WebSocketManager。
设置回调：处置惩罚毗连、消息、断开和错误变乱。
毗连WebSocket：调用 connect() 方法。
发送消息：通过 sendMessage 方法发送消息。
开释资源：在 onDestroy 中调用 disconnect() 方法。