基于okhttp和RxJava封装的自动重连的WebSocket

系统
RxWebSocket是一个基于okhttp和RxJava封装的WebSocket客户端,此库的核心特点是 除了手动关闭WebSocket(就是RxJava取消订阅),WebSocket在异常关闭的时候(onFailure,发生异常,如WebSocketException等等)。

[[414380]]

想了解更多内容,请访问:

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

一. 概述

RxWebSocket是一个基于okhttp和RxJava封装的WebSocket客户端,此库的核心特点是 除了手动关闭WebSocket(就是RxJava取消订阅),WebSocket在异常关闭的时候(onFailure,发生异常,如WebSocketException等等),会自动重连,永不断连.其次,对WebSocket做的缓存处理,同一个URL,共享一个WebSocket.

由于是基于RxJava封装,所以带来了无限可能,可以和RxBinding,Rxlifecycle一起使用,方便对WebSocket的管理.

效果图


项目已经上传Jcenter,依赖方法:

  1. //本项目 
  2. compile 'io.github.dzsf:RxWebSocket:1.0.0' 

二. 使用方法

0.初始化,可以也忽略直接使用.

如果你想使用自己的okhttpClient:

  1. OkHttpClient yourClient = new OkHttpClient(); 
  2. RxWebSocketUtil.getInstance().setClient(yourClient); 

 是否打印日志:

  1. RxWebSocketUtil.getInstance().setShowLog(BuildConfig.DEBUG); 

1.获取一个WebSocket,接收消息,多种方式:

  1. RxWebSocketUtil.getInstance().getWebSocketInfo(url) 
  2.         .subscribe(new Action1<WebSocketInfo>() { 
  3.             @Override 
  4.             public void call(WebSocketInfo webSocketInfo) { 
  5.                 mWebSocket = webSocketInfo.getWebSocket(); 
  6.                 Log.d("MainActivity", webSocketInfo.getString()); 
  7.                 Log.d("MainActivity""ByteString:" + webSocketInfo.getByteString()); 
  8.             } 
  9.         }); 
  10.  
  11. mWebSocket.send("hello word"); 
  12.  
  13. //get StringMsg 
  14. RxWebSocketUtil.getInstance().getWebSocketString(url) 
  15.         .subscribe(new Action1<String>() { 
  16.             @Override 
  17.             public void call(String s) { 
  18.             } 
  19.         }); 
  20. // get ByteString 
  21. RxWebSocketUtil.getInstance().getWebSocketByteString(url) 
  22.         .subscribe(new Action1<ByteString>() { 
  23.             @Override 
  24.             public void call(ByteString byteString) { 
  25.             } 
  26.         }); 
  27. //get WebSocket 
  28. RxWebSocketUtil.getInstance().getWebSocket(url) 
  29.         .subscribe(new Action1<WebSocket>() { 
  30.             @Override 
  31.             public void call(WebSocket webSocket) { 
  32.             } 
  33.         }); 
  34. // 带timeout的WebSocket,当在指定时间内没有收到消息,就重连WebSocket.为了适配小米平板. 
  35. RxWebSocketUtil.getInstance().getWebSocketInfo(url,10, TimeUnit.SECONDS) 
  36.         .subscribe(new Action1<WebSocketInfo>() { 
  37.             @Override 
  38.             public void call(WebSocketInfo webSocketInfo) { 
  39.             } 
  40.         }); 

2.发送消息:

  1. //用WebSocket的引用直接发 
  2. mWebSocket.send("hello word"); 
  3.  
  4. //url 对应的WebSocket 必须打开,否则报错 
  5. RxWebSocket.send(sendUrl, "hello"); 
  6. RxWebSocket.send(sendUrl, ByteString.EMPTY); 
  7.  
  8. //异步发送,若WebSocket已经打开,直接发送,若没有打开,打开一个WebSocket发送完数据,直接关闭. 
  9. RxWebSocket.asyncSend(sendUrl, "hello"); 
  10. RxWebSocket.asyncSend(sendUrl, ByteString.EMPTY); 

3.关闭WebSocket:

项目是依托RxJava实现的,所以关闭WebSocket的方法也就是在适当的时候注销 Observable,项目里的demo里,写了一个简单的lifecycle,将Observable生命绑定到Activity的onDestroy,自动注销.代码细节请看demo,因为内部实现了同一个URL的WebSocket共享机制,所以当外部所有持有这个URL的Observable都注销后,这个WebSocket连接就会自动关闭.请看原理解析部分

  1. //注意取消订阅,有多种方式,比如 rxlifecycle 
  2. mSubscription = RxWebSocketUtil.getInstance().getWebSocketInfo(url) 
  3.         .subscribe(new Action1<WebSocketInfo>() { 
  4.             @Override 
  5.             public void call(WebSocketInfo webSocketInfo) { 
  6.                 mWebSocket = webSocketInfo.getWebSocket(); 
  7.  
  8.                 if (webSocketInfo.isOnOpen()) { 
  9.                     Log.d("MainActivity"" on WebSocket open"); 
  10.                 } else { 
  11.                     String string = webSocketInfo.getString(); 
  12.  
  13.                     if (string != null) { 
  14.                         Log.d("MainActivity", string); 
  15.                         textview.setText(Html.fromHtml(string)); 
  16.                     } 
  17.  
  18.                     ByteString byteString = webSocketInfo.getByteString(); 
  19.  
  20.                     if (byteString != null) { 
  21.                         Log.d("MainActivity"
  22.                             "webSocketInfo.getByteString():" + 
  23.                             byteString); 
  24.                     } 
  25.                 } 
  26.             } 
  27.         }); 
  28.  
  29. //注销 
  30. if (mSubscription != null) { 
  31.     mSubscription.unsubscribe(); 
  32.  
  33. //lifecycle注销,详情看demo 
  34. RxWebSocketUtil.getInstance().getWebSocketString(url) 
  35.             .compose(this.<String>bindOnActivityEvent(ActivityEvent.onDestory)) 
  36.             .subscribe(new Action1<String>() { 
  37.                 @Override 
  38.                 public void call(String s) { 
  39.                 } 
  40.             }); 

三. 原理解析

1. 首先需要将okhttp的WebSocket包装成Observable,由于需要将WebSocket,Stringmsg,ByteString等信息一同发送给观察者所以先构建一个WebSocketInfo类,将信息封装:

  1. public class WebSocketInfo { 
  2.     private WebSocket mWebSocket; 
  3.     private String mString; 
  4.     private ByteString mByteString; 
  5.     private boolean onOpen; 
  6.     //其他省略 

onOpen字段主要用来判断当前的这个WebSocketInfo是否是当WebSocket打开时发送的消息(onOpen),这时,Stringmsg和ByteString都是null.

2. 将WebSocketInfo包装成Observable发出:

  1. private final class WebSocketOnSubscribe implements Observable.OnSubscribe<WebSocketInfo> { 
  2.     private String url; 
  3.     private WebSocket webSocket; 
  4.     private WebSocketInfo startInfo; 
  5.     private WebSocketInfo stringInfo; 
  6.     private WebSocketInfo byteStringInfo; 
  7.  
  8.     public WebSocketOnSubscribe(String url) { 
  9.         this.url = url; 
  10.         startInfo = new WebSocketInfo(true); 
  11.         stringInfo = new WebSocketInfo(); 
  12.         byteStringInfo = new WebSocketInfo(); 
  13.     } 
  14.  
  15.     @Override 
  16.     public void call(final Subscriber<?super WebSocketInfo> subscriber) { 
  17.         if (webSocket != null) { 
  18.             //降低重连频率 
  19.             if (!"main".equals(Thread.currentThread().getName())) { 
  20.                 SystemClock.sleep(2000); 
  21.             } 
  22.         } 
  23.  
  24.         initWebSocket(subscriber); 
  25.     } 
  26.  
  27.     private void initWebSocket( 
  28.         final Subscriber<?super WebSocketInfo> subscriber) { 
  29.         webSocket = client.newWebSocket(getRequest(url), 
  30.                 new WebSocketListener() { 
  31.                     @Override 
  32.                     public void onOpen(final WebSocket webSocket, 
  33.                         Response response) { 
  34.                         if (showLog) { 
  35.                             Log.d("RxWebSocketUtil", url + " --> onOpen"); 
  36.                         } 
  37.  
  38.                         webSocketMap.put(url, webSocket); 
  39.                         AndroidSchedulers.mainThread().createWorker().schedule(new Action0() { 
  40.                                 @Override 
  41.                                 public void call() { 
  42.                                     if (!subscriber.isUnsubscribed()) { 
  43.                                         subscriber.onStart(); 
  44.                                         startInfo.setWebSocket(webSocket); 
  45.                                         subscriber.onNext(startInfo); 
  46.                                     } 
  47.                                 } 
  48.                             }); 
  49.                     } 
  50.  
  51.                     @Override 
  52.                     public void onMessage(WebSocket webSocket, String text) { 
  53.                         if (!subscriber.isUnsubscribed()) { 
  54.                             stringInfo.setWebSocket(webSocket); 
  55.                             stringInfo.setString(text); 
  56.                             subscriber.onNext(stringInfo); 
  57.                         } 
  58.                     } 
  59.  
  60.                     @Override 
  61.                     public void onMessage(WebSocket webSocket, ByteString bytes) { 
  62.                         if (!subscriber.isUnsubscribed()) { 
  63.                             byteStringInfo.setWebSocket(webSocket); 
  64.                             byteStringInfo.setByteString(bytes); 
  65.                             subscriber.onNext(byteStringInfo); 
  66.                         } 
  67.                     } 
  68.  
  69.                     @Override 
  70.                     public void onFailure(WebSocket webSocket, Throwable t, 
  71.                         Response response) { 
  72.                         if (showLog) { 
  73.                             Log.e("RxWebSocketUtil"
  74.                                 t.toString() + 
  75.                                 webSocket.request().url().uri().getPath()); 
  76.                         } 
  77.  
  78.                         if (!subscriber.isUnsubscribed()) { 
  79.                             subscriber.onError(t); 
  80.                         } 
  81.                     } 
  82.  
  83.                     @Override 
  84.                     public void onClosing(WebSocket webSocket, int code, 
  85.                         String reason) { 
  86.                         webSocket.close(1000, null); 
  87.                     } 
  88.  
  89.                     @Override 
  90.                     public void onClosed(WebSocket webSocket, int code, 
  91.                         String reason) { 
  92.                         if (showLog) { 
  93.                             Log.d("RxWebSocketUtil"
  94.                                 url + " --> onClosed:code= " + code); 
  95.                         } 
  96.                     } 
  97.                 }); 
  98.         subscriber.add(new MainThreadSubscription() { 
  99.                 @Override 
  100.                 protected void onUnsubscribe() { 
  101.                     webSocket.close(3000, "手动关闭"); 
  102.                 } 
  103.             }); 
  104.     } 

实现一个WebSocketOnSubscribe 将WebSocket的回调转化成subscriber调用.发送给Observable下游.在onOpen时调用 subscriber.onStart(),并且发送一个onOpen的WebSocketInfo.在subscriber注销的时候关闭WebSocket.在call方法最上面有个SystemClock.sleep(2000),这个主要是为了降低在断连的时候的重连频率,将在下面讲到.

包装成Observable:

  1. Observable.create(new WebSocketOnSubscribe(url)) 
  2.             .subscribeOn(Schedulers.io()) 
  3.             .observeOn(AndroidSchedulers.mainThread()); 

3. 实现自动重连:

  1. Observable.create(new WebSocketOnSubscribe(url)) 
  2.             //自动重连 
  3.             .timeout(timeout, timeUnit).retry() 
  4.             .subscribeOn(Schedulers.io()) 
  5.             .observeOn(AndroidSchedulers.mainThread()); 

RxJava retry操作符,很完美的实现了这个功能,当上游发出Throwable的时候,retry将错误吃掉,并重新调用 onSubscribe的call方法,也就是WebSocketOnSubscribe的call,就会重新初始化一个WebSocket连接,达到重连的目的,如果一直没有网络,这个retry的调用频率非常高,所以在call方法里面,当是重连的时候,就SystemClock.sleep(2000),休眠2秒,这样重连的频率就是2秒重连一次. 当然在retry上面还有一个timeout操作符.当subscriber.onNext()在指定时间间隔里没有调用,就发出一个timeoutException,让retry重连WebSocket.这个主要是为了适配部分国产机型,当WebSocket发生连接异常时,不会及时发出错误,如小米平板.在每次重连都会把原来的WebSocket关闭.

4. 实现同一个URL的WebSocket共享

  1. Observable.create(new WebSocketOnSubscribe(url)) 
  2.         //自动重连 
  3.         .timeout(timeout, timeUnit) 
  4.         .retry() 
  5.         //共享 
  6.         .doOnUnsubscribe(new Action0() { 
  7.             @Override 
  8.             public void call() { 
  9.                 observableMap.remove(url); 
  10.                 webSocketMap.remove(url); 
  11.  
  12.                 if (showLog) { 
  13.                     Log.d("RxWebSocketUtil""注销"); 
  14.                 } 
  15.             } 
  16.         }) 
  17.         .doOnNext(new Action1<WebSocketInfo>() { 
  18.             @Override 
  19.             public void call(WebSocketInfo webSocketInfo) { 
  20.                 if (webSocketInfo.isOnOpen()) { 
  21.                     webSocketMap.put(url, webSocketInfo.getWebSocket()); 
  22.                 } 
  23.             } 
  24.         }) 
  25.         .share() 
  26.         .subscribeOn(Schedulers.io()) 
  27.         .observeOn(AndroidSchedulers.mainThread()); 

实现共享功能,主要是为了防止一个URL的WebSocket,建立多个连接,这个主要是由RxJava的share操作符实现,share操作符,使得一个Observable可以有多个subscriber,当有多个subscriber时,当所有的subscriber都取消订阅,这个Observable才会取消订阅.

getWebSocketInfo()方法完整代码:

  1. public Observable<WebSocketInfo> getWebSocketInfo(final String url, final long timeout, final TimeUnit timeUnit) { 
  2.     Observable<WebSocketInfo> observable = observableMap.get(url); 
  3.     if (observable == null) { 
  4.         observable = Observable.create(new WebSocketOnSubscribe(url)) 
  5.                 //自动重连 
  6.                 .timeout(timeout, timeUnit) 
  7.                 .retry() 
  8.                 //共享 
  9.                 .doOnUnsubscribe(new Action0() { 
  10.                     @Override 
  11.                     public void call() { 
  12.                         observableMap.remove(url); 
  13.                         webSocketMap.remove(url); 
  14.                         if (showLog) { 
  15.                             Log.d("RxWebSocketUtil""注销"); 
  16.                         } 
  17.                     } 
  18.                 }) 
  19.                 .doOnNext(new Action1<WebSocketInfo>() { 
  20.                     @Override 
  21.                     public void call(WebSocketInfo webSocketInfo) { 
  22.                         if (webSocketInfo.isOnOpen()) { 
  23.                             webSocketMap.put(url, webSocketInfo.getWebSocket()); 
  24.                         } 
  25.                     } 
  26.                 }) 
  27.                 .share() 
  28.                 .subscribeOn(Schedulers.io()) 
  29.                 .observeOn(AndroidSchedulers.mainThread()); 
  30.         observableMap.put(url, observable); 
  31.     } else { 
  32.         observable = Observable.merge(Observable.just(new WebSocketInfo(webSocketMap.get(url), true)), observable); 
  33.     } 
  34.     return observable; 

doOnUnsubscribe作用:在Observable注销,即 WebSocket关闭时,移除map中的缓存的Observable和WebSocket.

doOnNext作用: 判断接收到的WebSocketInfo是否是WebSocket在onOpen的时候发的,然后将其缓存起来.作用就是:如果有一个相同的URL订阅Observable,就从缓存中取,这个时候我们应该把一个WebSocket的onOpen事件也发给这个订阅者:

  1. //使用merge操作符,将onOpen事件发给订阅者 
  2. observable = Observable.merge(Observable.just(new WebSocketInfo(webSocketMap.get(url), true)), observable); 

这样的话,同一个URL的WebSocket,不管在什么地方什么时间订阅,都能收到一个onOpen事件,外部表现的就像一个新的WebSocket.

getWebSocketInfo方法的几种变体:

  1. /** 
  2.  * default timeout: 30 days 
  3.  * <p> 
  4.  * 若忽略小米平板,请调用这个方法 
  5.  * </p> 
  6.  */ 
  7. public Observable<WebSocketInfo> getWebSocketInfo(String url) { 
  8.     return getWebSocketInfo(url, 30, TimeUnit.DAYS); 
  9.  
  10. public Observable<String> getWebSocketString(String url) { 
  11.     return getWebSocketInfo(url) 
  12.             .map(new Func1<WebSocketInfo, String>() { 
  13.                 @Override 
  14.                 public String call(WebSocketInfo webSocketInfo) { 
  15.                     return webSocketInfo.getString(); 
  16.                 } 
  17.             }) 
  18.             .filter(new Func1<String, Boolean>() { 
  19.                 @Override 
  20.                 public Boolean call(String s) { 
  21.                     return s != null
  22.                 } 
  23.             }); 
  24.  
  25. public Observable<ByteString> getWebSocketByteString(String url) { 
  26.     return getWebSocketInfo(url) 
  27.             .map(new Func1<WebSocketInfo, ByteString>() { 
  28.                 @Override 
  29.                 public ByteString call(WebSocketInfo webSocketInfo) { 
  30.                     return webSocketInfo.getByteString(); 
  31.                 } 
  32.             }) 
  33.             .filter(new Func1<ByteString, Boolean>() { 
  34.                 @Override 
  35.                 public Boolean call(ByteString byteString) { 
  36.                     return byteString != null
  37.                 } 
  38.             }); 
  39.  
  40. public Observable<WebSocket> getWebSocket(String url) { 
  41.     return getWebSocketInfo(url) 
  42.             .map(new Func1<WebSocketInfo, WebSocket>() { 
  43.                 @Override 
  44.                 public WebSocket call(WebSocketInfo webSocketInfo) { 
  45.                     return webSocketInfo.getWebSocket(); 
  46.                 } 
  47.             }); 

5 . send信息到服务端

上面已经讲到WebSocketInfo包含了WebSocket,所以在订阅后,就可以拿到这个WebSocket引用就可以WebSocket.send发送消息到服务端.当然我们的RxWebSocketUtil已经将开启的WebSocket已经缓存.所以我们也可以这样发消息:

  1. /** 
  2.  * 如果url的WebSocket已经打开,可以直接调用这个发送消息. 
  3.  * 
  4.  * @param url 
  5.  * @param msg 
  6.  */ 
  7. public void send(String url, String msg) { 
  8.     WebSocket webSocket = webSocketMap.get(url); 
  9.     if (webSocket != null) { 
  10.         webSocket.send(msg); 
  11.     } else { 
  12.         throw new IllegalStateException("The WebSokcet not open"); 
  13.     } 
  14.  
  15. /** 
  16.  * 如果url的WebSocket已经打开,可以直接调用这个发送消息. 
  17.  * 
  18.  * @param url 
  19.  * @param byteString 
  20.  */ 
  21. public void send(String url, ByteString byteString) { 
  22.     WebSocket webSocket = webSocketMap.get(url); 
  23.     if (webSocket != null) { 
  24.         webSocket.send(byteString); 
  25.     } else { 
  26.         throw new IllegalStateException("The WebSokcet not open"); 
  27.     } 

当指定的URL的WebSocket没有打开会直接报错.

异步发送消息到服务端

  1. /** 
  2.  * 不用关心url 的WebSocket是否打开,可以直接发送 
  3.  * 
  4.  * @param url 
  5.  * @param msg 
  6.  */ 
  7. public void asyncSend(String url, final String msg) { 
  8.     getWebSocket(url) 
  9.             .first() 
  10.             .subscribe(new Action1<WebSocket>() { 
  11.                 @Override 
  12.                 public void call(WebSocket webSocket) { 
  13.                     webSocket.send(msg); 
  14.                 } 
  15.             }); 
  16.  
  17.  
  18. /** 
  19.  * 不用关心url 的WebSocket是否打开,可以直接发送 
  20.  * 
  21.  * @param url 
  22.  * @param byteString 
  23.  */ 
  24. public void asyncSend(String url, final ByteString byteString) { 
  25.     getWebSocket(url) 
  26.             .first() 
  27.             .subscribe(new Action1<WebSocket>() { 
  28.                 @Override 
  29.                 public void call(WebSocket webSocket) { 
  30.                     webSocket.send(byteString); 
  31.                 } 
  32.             }); 

这两种发送方式,你不用关心URL的WebSocket是否打开,可以直接发送.实现思路也很简单,getWebSocket(url)会获取到Observable,或者是从缓存中取,或者是重新开启一个WebSocket,但你都不需要关心,经过first操作符后,如果是从缓存取的Observable,就注销的当前的Observable,当是新开的WebSocket,注销掉当前的subscriber后,就没有其他subscriber了,这个新开的WebSocket就会关闭(share操作符作用).

想了解更多内容,请访问:

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

 

责任编辑:jianghua 来源: 鸿蒙社区
相关推荐

2023-12-11 07:12:21

心跳检测重连机制服务端

2021-02-26 12:37:39

WebSocketOkHttp连接

2017-05-25 11:49:30

Android网络请求OkHttp

2021-12-07 10:23:27

鸿蒙HarmonyOS应用

2024-03-19 08:45:45

WebSocketSpring应用开发

2021-11-09 09:30:52

OkHttp面试Android

2020-03-19 10:13:13

OkHttpWebSocket

2014-09-01 10:22:11

Node.js技术架构

2017-03-22 13:20:07

RxJavaSingleCompletable

2024-04-03 15:40:14

WebSocketWeb应用Spring

2018-04-20 09:36:23

NettyWebSocket京东

2024-11-04 08:00:00

Netty客户端

2014-03-25 14:21:18

WebSocket实时

2012-06-04 14:41:16

Win7连网

2024-08-07 08:22:27

2024-01-26 08:41:55

Fluent工具包高并发

2021-10-25 10:30:12

JavaScript开发 代码

2024-03-21 08:34:49

Vue3WebSocketHTTP

2024-06-11 10:01:10

2023-03-13 17:18:09

OkHttp同步异步
点赞
收藏

51CTO技术栈公众号