Android中使用WebSocket

Android WebSocket 实现长连接及心跳检测与断线重连
转载 已于 2022-05-25 15:14:03 修改 · 1w 阅读 · 16 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/mr_lichao/article/details/106102004
文章标签：

#websocket #java #Android #socket #长连接

于 2021-02-18 15:53:46 首次发布
本文详细介绍了在Android环境中如何使用Java-WebSocket库建立WebSocket长连接，包括心跳检测机制以保持连接活跃，以及断线后自动重连的实现方法。示例代码展示了连接建立、消息收发、关闭连接和异常处理的过程，并提供了心跳检测的实现。

参考网址：Android WebSocket 建立一个长连接（带心跳检测）Activity页面可接发信息_mr_lichao的博客-优快云博客_android websocket 心跳
Android中使用WebSocket_Huang兄-优快云博客_android websocket

//导包：implementation "org.java-websocket:Java-WebSocket:1.4.0"
private WebSocketClient webSocketClient;
    private void webSocket(){
        //https://blog.youkuaiyun.com/huangyuan_xuan/article/details/109325021
        //https://www.jianshu.com/p/ee5bdb999df6
        new Thread(){
            @Override
            public void run() {
                super.run();
                try{
                    URI serverURI = URI.create("ws://192.168.1.1:8080?");
                    webSocketClient = new WebSocketClient(serverURI) {
                        //打开连接
                        @Override
                        public void onOpen(ServerHandshake handshakedata) {
                            System.out.println("onOpen:服务器状态:"+handshakedata.getHttpStatusMessage());
                        }
                        //服务端返回消息
                        @Override
                        public void onMessage(String message) {
                            System.out.println("onMessage:"+message); //得到返回的数据
                        }
                        //关闭连接
                        @Override
                        public void onClose(int code, String reason, boolean remote) {
                            System.out.println("onClose:"+code+reason+remote);
                        }
                        //出现异常
                        @Override
                        public void onError(Exception ex) {
                            System.out.println("onError:"+ex.fillInStackTrace());
                        }
                    };
                    webSocketClient.connectBlocking();
                    mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//开启心跳检测
                }catch (Exception e){
                    System.out.println("webSocket:"+e.fillInStackTrace());
                }
            }
        }.start();
    }
    //******websocket心跳检测********
    private String heartbeat = "123";//心跳
    private static final long HEART_BEAT_RATE = 10 * 1000;//每隔10秒进行一次对长连接的心跳检测
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("心跳包检测websocket连接状态");
            if (webSocketClient != null) {
                if (webSocketClient.isClosed()) {
                    reconnectWs();
                }else {
                    //业务逻辑 这里如果服务端需要心跳包为了防止断开 需要不断发送消息给服务端
                    webSocketClient.send(heartbeat);
                    System.out.println("客户端发送消息:"+heartbeat);
                }
            } else {
                //如果client已为空，重新初始化连接
                webSocketClient = null;
                webSocket();
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };
    //开启重连
    private void reconnectWs() {
        mHandler.removeCallbacks(heartBeatRunnable);
        new Thread() {
            @Override
            public void run() {
                try {
                    //connectBlocking多出一个等待操作，会先连接再发送，否则未连接发送会报错
                    webSocketClient.reconnectBlocking();
                } catch (Exception e) {
                    System.out.println("reconnectWs:"+e.fillInStackTrace());
                }
            }
        }.start();
    }
	@Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacks(heartBeatRunnable);
        if (webSocketClient!=null){
            webSocketClient.close();
            webSocketClient = null;
        }
    }

包含断线重连工具类

package com.service;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.enums.ReadyState;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;

public class MyWebSocket {
    private WebSocketClient webSocketClient;
    private String data;
    private boolean bl = false;
    private boolean bl2 = false;
    public MyWebSocket(String data) {
        this.data = data;
        webSocket(data);
    }
    private void webSocket(String data){
        new Thread(){
            @Override
            public void run() {
                super.run();
                try{
                    URI serverURI = URI.create("ws://"+IP+":"+ 端口);
                    webSocketClient = new WebSocketClient(serverURI) {
                        //打开连接
                        @Override
                        public void onOpen(ServerHandshake handshakedata) {
                            System.out.println("WebSocket:::onOpen:");
                            if (bl2)
                                sendData(data);
                        }
                        //服务端返回消息
                        @Override
                        public void onMessage(String message) {
                            //System.out.println("WebSocket:::onMessage:"+message);
                            listener.getMessage(message);
                            bl = false;
                        }
                        //关闭连接
                        @Override
                        public void onClose(int code, String reason, boolean remote) {
                            System.out.println("WebSocket:::onClose:"+code);
                            if (!bl){
                                listener.closeWebSocket(code,reason,remote);
                                bl = true;
                            }
                            bl2 = false;
                        }
                        //出现异常
                        @Override
                        public void onError(Exception ex) {
                            String str = ex.fillInStackTrace().toString();
                            System.out.println("WebSocket:::onError:"+str);
                            if (!bl){
                                listener.closeWebSocket(-1,str,false);
                                bl = true;
                            }
                            bl2 = false;
                        }
                    };
                    //webSocketClient.connectBlocking();
                    reConnect();
                    sendData(data);
                }catch (Exception e){
                    System.out.println("WebSocket:::"+e.fillInStackTrace());
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                super.run();
                while (true){
                    //webSocket连接断开后一直重复尝试连接直到连接成功为止
                    if (webSocketClient != null&&webSocketClient.isClosed()) {
                        reConnect();
                        if (!bl2)
                            bl2 = true;
                    }
                }
            }
        }.start();
    }
    //断线重连方法
    private void reConnect(){
        try{
            if (webSocketClient==null)
                return;
            if (webSocketClient.getReadyState().equals(ReadyState.NOT_YET_CONNECTED)) {
                webSocketClient.connectBlocking();
            } else if (webSocketClient.getReadyState().equals(ReadyState.CLOSING)
                    || webSocketClient.getReadyState().equals(ReadyState.CLOSED)) {
                webSocketClient.reconnectBlocking();
            }
        }catch (Exception e){
            System.out.println("WebSocket:::reConnect:"+e.fillInStackTrace());
        }
    }
    public void sendData(String data){
        //防止WebsocketNotConnectedException
        while (!webSocketClient.getReadyState().equals(ReadyState.OPEN)){
            System.out.equals("WebSocket:::连接断开了");
        }
        if (webSocketClient != null&&!webSocketClient.isClosed()) {
            webSocketClient.send(data);
        }
    }
    public boolean isClosed(){
        if (webSocketClient != null) {
            return webSocketClient.isClosed();
        }
        return false;
    }
    public void closeWebSocket(){
        if (webSocketClient!=null){
            webSocketClient.close();
            webSocketClient = null;
        }
    }

    WebSocketListener listener;
    public void setWebSocket(WebSocketListener listener){
        this.listener = listener;
    }
    public interface WebSocketListener{
        void getMessage(String message);
        void closeWebSocket(int code, String reason, boolean remote);
    }
}

错误码

Android websocket详细使用方法
lanrenxiaowen的博客
11-10 1万+
里面加入了断线重连、心跳机制、退出释放资源，废话不多直接开干 1.添加依赖 implementation "org.java-websocket:Java-WebSocket:1.5.1" 2、添加使用类 import android.util.Log; import org.java_websocket.client.WebSocketClient; import org.java_websocket.drafts.Draft_6455; import org.java_websocket.hands
Android中 使用 WebSocket 实现消息通信
2401_87288903的博客
09-21 1944
心跳、发送请求都属于客户端主动发送请求，对于请求结果我们分为成功和失败以及超时，发送超时我们是收不到服务器任何回复的，所以我们需要在发送之后将发送放在超时任务队列中，如果请求成功将任务从超时队列中移除，超时从超时队列中获取任务重新请求。此处我们要做的处理是，如果收到连接失败或者断开连接的回调 需要重新连接，我们重新调用一次连接方法即可，并且如果超过三次重连失败，我们在业务中可以通过调用接口来获取数据，避免数据丢失，此处细节省略。Log.d(TAG, “onConnected: 连接成功”);
android 对webSocket的使用
12-20
在android中如何使用websocket
Android中websocket的运用
06-01
Android中建立长连接我们需要websocket，本人根据项目中的经验，写了一个demo，希望对大家有用
Android WebSocket 深度解析与实战：原理、封装与最佳实践
qq_41821190的博客
10-20 895
在现代 App 中，实时通信已成为刚需：聊天室消息秒达直播间弹幕即时刷出股票、币价数据实时刷新这些背后都有一个核心技术支撑：👉WebSocket相比传统的 HTTP 轮询，WebSocket 是真正的「双向实时通信协议面试题答案要点WebSocket 和 HTTP 的区别？HTTP 是短连接，请求-响应模式；WebSocket 是持久双向连接。WebSocket 心跳机制怎么做？客户端定期发送 ping；服务器回复 pong。如何实现断线重连？
android中的websocket 应用
a54349463的博客
03-06 253
websocket 在实际的应用中不仅仅能做聊天应用，还可以利用websocket长连接保持数据的实时更新以及信息的推送。 websocket 的实现的关键点 第一个：首先需要引入 java-websocket.jar 包， 这里我使用的版本时1.3.1。 接下来就开始了，不同的业务有不同的需求，我们根据业务需求封装一下websocket 请求 在runable中实例web...
Android使用WebSocket
一个有趣的地方
03-08 2029
Android websocket基础使用
在Android中使用WebSocket实现消息通信的方法详解
08-18
Android 中使用 WebSocket 实现消息通信的方法详解 在移动 APP 中，消息推送功能是不可或缺的功能之一。为了实现消息推送功能，我们可以使用第三方推送的 SDK，但是对于消息聊天这种及时性有要求的或者三方推送不...
Android中使用WebSocket实现群聊和消息推送功能(不使用WebView)
09-02
总之，使用WebSocket在Android中实现群聊和消息推送功能，能够提供实时、低延迟的通信体验，而不需要借助WebView。通过选择合适的WebSocket库和正确地处理客户端和服务端的交互，可以构建出高效且稳定的即时通讯应用...
在Android中使用WebSocket
chuyouyinghe的专栏
01-03 2740
WebSocket是一种通信协议，它提供了一个单一的、长期的连接上的全双工通信通道。它设计用于在Web浏览器和Web服务器中实现，但也可以用于其他应用。与传统的基于请求-响应和无状态的HTTP连接不同，WebSocket允许客户端和服务器之间的双向通信。这使得实时数据交换和推送功能成为可能。
Android使用websocket
weixin_43976036的博客
09-23 2767
websocket是web端的一个长连接协议，也是用来实时通知的一门技术，在不刷手动新界面的情况下可以实时刷新界面，比如一个报警触发，web端要实时弹窗提示，这个情况下就需要websocket了，现在先来谈谈android上如果使用websocket。 1.添加依赖 implementation 'org.java-websocket:Java-WebSocket:1.3.9' 2.使用封装类WebSocketHelper import android.util.Log; import org
webSocket实现Android客户端之间简单的通讯
09-22
webSocket实现Android客户端之间简单的通讯，或者群发
Android 使用WebSocket通信
gdvfs12的博客
05-24 3096
APP端实现 1.添加依赖 implementation "org.java-websocket:Java-WebSocket:1.5.1" 2.加入网络请求权限 <uses-permission android:name="android.permission.INTERNET" /> 3.创建客户端类并继承WebSocketClient，需要实现它的四个抽象方法和构造函数 import android.util.Log; import org.java_websocket.client
Android程序中使用websocket通信(java-websocket)
m0_49083276的博客
08-23 3175
需要和硬件保持实时通信在以前的消息推送机制中，用的都是http轮询（polling），做一个定时器定时向服务器发送请求，这种方式是非常消耗资源的，因为它本质还是http请求，而且显得非常笨拙。而WebSocket 在浏览器和服务器完成一个握手的动作，在建立连接之后，服务器可以主动传送数据给客户端，客户端也可以随时向服务器发送数据。
android websocket的使用
MINGZHNGLEI的专栏
12-05 6594
websocket的使用 上一篇我写的是notifation通知的使用，这篇呢，介绍下websocket实现即时通讯 首先在这里说下websocket WebSocket 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯，它建立在 TCP 之上，同 HTTP 一样通过 TCP 来传输数据，但是它和 HTTP 最大不同是：
在安卓中使用WebSocket
king的专栏
06-20 5892
WebSocket是一种在Web浏览器和服务器之间进行实时双向通信的协议。与传统的HTTP请求-响应模型不同，WebSocket允许服务器主动向客户端推送数据，而不需要客户端发起请求。当然，发展到如今，WebSocket已经不再局限于Web浏览器了，也可以在移动应用、桌面应用上使用。
Android 使用Websocket
byszy的专栏
10-26 1792
1.Websocket背景与功能简介传统的Android网络请求无法适应信息变化频繁的应用，比如金融证券的实时信息，Web 导航应用中的地理位置获取，社交网络的实时消息推送等。传统的请求-响应模式的 Web 开发在处理此类业务场景时，通常采用实时通讯方案，常见的是： 轮询，原理简单易懂，就是客户端通过一定的时间间隔以频繁请求的方式向服务器发送请求，来保持客户端和服务器端的数据同步。问题很明显，当
android 中怎么使用webSocket
最新发布
10-24
<think>我们参考了多个关于在Android中使用WebSocket的引用，结合这些信息为用户提供实现方法的步骤和关键代码。 步骤如下： 1. 添加依赖：在项目的build.gradle文件中添加WebSocket库的依赖。 2. 创建WebSocket客户端：使用库提供的API创建WebSocket客户端实例。 3. 建立连接并设置监听器：连接到WebSocket服务器，并设置回调以处理连接状态、接收消息等事件。 4. 发送消息：通过建立的连接发送消息。 5. 断开连接：在适当的时候关闭连接。 根据引用，我们注意到以下几点： - 引用[1]提到WebSocket实现了双向通信，是构建响应式应用的有力工具。 - 引用[2]提到在Android的WebView中，如果平台不支持WebSocket，Socket.io会使用其他方式（如XHR）实现，但这里我们讨论的是原生WebSocket。 - 引用[3]提到了在客户端中，WebSocket的回调方法不在主线程，更新UI需要切换到主线程；同时也提到了可以使用Service和广播机制来更新UI。 - 引用[4]提到了处理超时和重连的机制。 下面我们分步骤详细说明： ### 步骤1：添加依赖 常用的WebSocket库有`Java-WebSocket`和`OkHttp`。这里以`OkHttp`为例，因为它广泛用于Android网络请求，并且支持WebSocket。 在app模块的`build.gradle`文件中添加依赖： ```groovy dependencies { implementation 'com.squareup.okhttp3:okhttp:4.9.3' // 使用较新版本，注意版本号可能更新 } ``` ### 步骤2：创建WebSocket客户端 使用OkHttp的`OkHttpClient`来创建WebSocket客户端实例。 ```java OkHttpClient client = new OkHttpClient(); ``` ### 步骤3：建立连接并设置监听器 创建一个`Request`对象指定服务器地址，然后通过`newWebSocket`方法建立连接，并传入一个`WebSocketListener`以处理事件。 ```java Request request = new Request.Builder() .url("ws://your_websocket_server_url") // 替换为你的WebSocket服务器地址 .build(); WebSocket webSocket = client.newWebSocket(request, new WebSocketListener() { @Override public void onOpen(WebSocket webSocket, Response response) { // 连接成功 // 可以在这里发送一条初始消息，如果需要 webSocket.send("Hello from Android"); } @Override public void onMessage(WebSocket webSocket, String text) { // 收到文本消息 // 注意：这个方法在后台线程执行，更新UI需要使用Handler或runOnUiThread runOnUiThread(() -> { // 更新UI，例如将消息显示在TextView上 textView.append("Received: " + text + "\n"); }); } @Override public void onClosed(WebSocket webSocket, int code, String reason) { // 连接关闭 } @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) { // 连接失败 t.printStackTrace(); // 可以在这里实现重连逻辑 } }); // 为了避免内存泄漏，在不需要的时候应该取消请求（例如在Activity的onDestroy中） client.dispatcher().executorService().shutdown(); ``` 注意：`runOnUiThread`是Activity的方法，如果在非Activity环境中，可以使用Handler或LiveData等机制更新UI。 ### 步骤4：发送消息 通过`WebSocket`对象的`send`方法发送消息。 ```java webSocket.send("This is a message from Android"); ``` ### 步骤5：断开连接 在适当的时候（如Activity销毁时）关闭连接。 ```java @Override protected void onDestroy() { super.onDestroy(); webSocket.close(1000, "Goodbye!"); // 1000是正常关闭的状态码 } ``` ### 关于重连 引用[4]提到超时重连，可以在`onFailure`回调中实现重连逻辑。注意重连时可能需要设置延迟和次数限制。 ```java @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) { t.printStackTrace(); // 重连逻辑 reconnect(); } private void reconnect() { // 使用Handler延迟重连，避免频繁重连 new Handler(Looper.getMainLooper()).postDelayed(() -> { // 重新创建WebSocket连接 // 注意：这里需要重新执行步骤2和3（创建新的WebSocket连接） }, 5000); // 5秒后重连 } ``` ### 在Service中使用 如果需要在后台维持WebSocket连接，可以在Service中实现上述逻辑，并通过广播或绑定服务的方式与Activity通信。 以上就是在Android中使用WebSocket的基本方法。 §§相关问题§§ 1. WebSocket与HTTP长轮询有什么区别？ 2. 在Android中如何保证WebSocket连接的安全性（例如使用wss）？ 3. 如何实现WebSocket的断线重连机制？ 4. 如何在Android后台服务中维持WebSocket连接？ </think>以下是Android中使用WebSocket的完整实现方法，结合了关键引用信息和代码示例： ### 一、核心实现步骤 1. **添加依赖**（使用OkHttp库） 在`build.gradle`中添加： ```groovy implementation 'com.squareup.okhttp3:okhttp:4.12.0' // 包含WebSocket支持 ``` 2. **创建WebSocket客户端** ```java OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("ws://your_server_address") // 替换为实际地址 .build(); WebSocket webSocket = client.newWebSocket(request, new WebSocketListener() { @Override public void onOpen(WebSocket webSocket, Response response) { // 连接成功回调 webSocket.send("Hello Server!"); // 发送初始消息 } @Override public void onMessage(WebSocket webSocket, String text) { // 接收文本消息（注意：在后台线程执行） runOnUiThread(() -> { textView.append("Received: " + text + "\n"); // 更新UI }); } @Override public void onClosed(WebSocket webSocket, int code, String reason) { // 连接关闭回调 } @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) { // 连接失败处理（需实现重连机制）[^4] reconnect(); // 自定义重连方法 } }); ``` 3. **消息发送** ```java webSocket.send("Message from Android"); // 发送文本 ``` 4. **连接关闭** ```java webSocket.close(1000, "Normal closure"); // 状态码1000表示正常关闭 client.dispatcher().executorService().shutdown(); // 释放资源 ``` ### 二、关键注意事项 1. **线程处理** 所有回调均在后台线程执行，更新UI需切换到主线程： ```java runOnUiThread(() -> { /* 更新UI操作 */ }); // Activity中使用 // 或 new Handler(Looper.getMainLooper()).post(() -> { ... }); // 非Activity环境 ``` 2. **后台服务集成** 建议在`Service`中维护WebSocket连接，通过广播更新UI[^3]： ```java // Service中接收消息后发送广播 Intent intent = new Intent("WEB_SOCKET_MSG"); intent.putExtra("message", receivedMsg); sendBroadcast(intent); ``` 3. **重连机制实现**[^4] ```java private void reconnect() { new Handler().postDelayed(() -> { if (!isConnected) { initWebSocket(); // 重新初始化连接 } }, 5000); // 5秒后重试 } ``` ### 三、备选方案（WebView场景） 若需在WebView中使用WebSocket： 1. 平台会自动降级到XHR长轮询[^2] 2. 使用Socket.IO库： ```javascript // WebView中加载的JS代码 const socket = io("http://your_server"); socket.on("message", (data) => { console.log(data); }); ``` ### 四、安全建议 1. 生产环境使用`wss://`加密协议 2. 添加连接超时控制： ```java OkHttpClient client = new OkHttpClient.Builder() .connectTimeout(15, TimeUnit.SECONDS) .build(); ``` > **引用要点总结**： > - WebSocket实现双向实时通信[^1] > - 回调需处理线程切换问题[^3] > - 必须实现异常重连逻辑[^4] > - WebView中自动降级兼容[^2]
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值