Android中使用WebSocket

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

//导包：implementation "org.java-websocket:Java-WebSocket:1.4.0"
private WebSocketClient webSocketClient;
    private void webSocket(){
        //https://blog.csdn.net/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);
    }
}

错误码