android WebSocket链接demo

引入

implementation "org.java-websocket:Java-WebSocket:1.5.2"

创建 MyWebSocketService

public class MyWebSocketService extends Service {

    public WebSocketClient webSocketClient;
    private ServiceCallBack serviceCallBack;

    @Override
    public void onCreate() {
        super.onCreate();
        if (webSocketClient!=null){
            if (webSocketClient.isClosed()) {
                reconnectWs();
            }
        }else{
//            webSocketClient=null;
            initSocketClient();
        }
        mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//开启心跳检测
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }


    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new Binder();
    }

    public class Binder extends android.os.Binder {
        public MyWebSocketService getService() {
            return MyWebSocketService.this;
        }
    }


    /**
     * 连接websocket
     */
    private void connect() {
        new Thread() {
            @Override
            public void run() {
                try {
                    //connectBlocking多出一个等待操作，会先连接再发送，否则未连接发送会报错
                    webSocketClient.connectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    /**
     * 打开ws
     */
    private void initSocketClient(){
        //长连接地址
        URI serverURI = URI.create("ws://***/***/**");
        webSocketClient = new WebSocketClient(serverURI) {
            @Override
            public void onOpen(ServerHandshake handshakedata) {
                Log.e("webSocket", "onOpen: ");
            }

            @Override
            public void onMessage(String message) {
                Log.e("webSocket", "onMessage: "+message);
                if (serviceCallBack != null) {
                    // 调用接口方法，将需要传递的值作为参数传递
                    serviceCallBack.getServiceData(message);
                }
            }
            @Override
            public void onClose(int code, String reason, boolean remote) {
                Log.e("webSocket", "onClose: "+reason+"----"+code);
            }

            @Override
            public void onError(Exception ex) {
                Log.e("webSocket", "onError: ");
            }
        };
        connect();
    }


    /**
     * websocket心跳检测
     */
    private static final long HEART_BEAT_RATE = 5 * 1000;//每隔15秒进行一次对长连接的心跳检测
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            Log.e("webSocket", "心跳包检测websocket连接状态");
            if (webSocketClient != null) {
                if (webSocketClient.isClosed()) {
                    reconnectWs();
                }
            } else {
                //如果client已为空，重新初始化连接
                webSocketClient = null;
                initSocketClient();
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };


    /**
     * 开启重连
     */
    private void reconnectWs() {
        mHandler.removeCallbacks(heartBeatRunnable);
        new Thread() {
            @Override
            public void run() {
                try {
                    Log.e("webSocket", "开启重连");
                    webSocketClient.reconnectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


    //定义的接口
    public interface ServiceCallBack {
        void getServiceData(String data);
    }

    public void setServiceCallBack(ServiceCallBack serviceCallBack){
        this.serviceCallBack = serviceCallBack;
    }
}

在activity 中使用

fun bindService(){
        val bindIntent=Intent(this,MyWebSocketService::class.java)
        bindService(bindIntent,object :ServiceConnection{
            override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
                //服务与活动成功绑定
                Log.e("webSocket", "服务与活动成功绑定");
                val binder=service as (MyWebSocketService.Binder)
                val webSocketService=binder.service
                webSocketService.setServiceCallBack { object :MyWebSocketService.ServiceCallBack{
                    override fun getServiceData(data: String?) {
                        Log.e("webSocket", "回调数据: "+data );
                       val  handlerMessage = Message.obtain();
                        handlerMessage.obj=data
                        handler.sendMessage(handlerMessage)
                    }

                } }
            }

            override fun onServiceDisconnected(name: ComponentName?) {
                //服务与活动断开
                Log.e("webSocket", "服务与活动成功断开");
            }

        },BIND_AUTO_CREATE)
    }


    private val handler=Handler(object :Handler.Callback{
        override fun handleMessage(msg: Message): Boolean {
            Log.e("webSocket", "服务返回数据: "+msg.obj.toString());
            return true
        }

    })

注册service

<service android:name=".demo.MyWebSocketService" />