android中热修复功能实现详解_Android进阶必备：RxJava全面学习(4)——功能性操作符详解...

关于RxJava我会持续更新，从原理到使用一步步由浅至深带大家对RxJava有一个深入的学习，欢迎大家持续关注。如果觉得这里代码排版不是很舒服的读者可以关注我的微信公众号“IT工匠”，我会同步更新，另外微信公众号上还有很多互联网必备资源(涉及算法、数据结构、java、深度学习、计算机网络、python、Android等互联网技术资料)，欢迎大家关注、交流。

RxJava之所以强大的一大原因是其提供了功能完备的各类操作符，有了这些操作符，我们可以完成很多功能。所谓的操作符其实核心功能只有一个，那就是创建被观察者以及发送事件，如果看过我写的《RxJava全面学习(1)——原理介绍&入门使用》一文，一定会对Observable.create()方法有很深的印象，当时我们是使用Observable.create()方法去创建被观察者以及发送事件的，其实Observable.create()方法就是RxJava为我们提供的一个最基本的操作符，RxJava为我们提供的操作符大致有以下这些：

本文我们来对RxJava中的功能性操作符进行学习，本文目录如下：

功能性操作符

作用：在被观察者进行事件发送的时候完成一些比如线程调度、错误处理等的功能性任务。

连接观察者&被观察者

subscrible()

作用：连接观察者与被观察者，起到订阅的作用

具体使用：前面每一个实例都有用到。

线程调度

需求场景：快速指定观察者和被观察者所在的线程。

默认情况下观察者与被观察者都是工作在创建其的线程中，一般是主线程，要实现真正的异步任务，我们就需要让被观察者在子线程中生产时间、观察者在主线程中接收事件，比如在被观察者中执行耗时操作，将耗时操作的结果作为事件发送给观察者，观察者在UI线程中接收被观察者发送的事件(异步任务的处理结果)，并更新UI。

为了实现上述场景，RxJava为我们提供了两个常用的线程调度的操作符：

1. subscribeOn()：指定被观察者所在的线程
2. observeOn()：指定观察者所在的线程

具体使用方法如下：

public void threadRun() { print("主线程：" + Thread.currentThread().getId()); Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter emitter) throws Exception { print("被观察者所在的线程是：" + Thread.currentThread().getId()); emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); } }).observeOn(Schedulers.newThread()).subscribeOn(Schedulers.newThread()).subscribe(new Consumer() { @Override public void accept(Integer integer) throws Exception { print("观察者所在的线程是：" + Thread.currentThread().getId()); print("接收到事件：" + integer); } });}

执行结果如下：

在上面的代码中，我们使用subscribeOn()和observeOn()分别指定了被观察者和观察者所在的线程，传入这两个方法中的实参Schedulers.newThread()代表相对于当前线程的新线程，我们还可以传入下面的几种值来达到不同的线程调度的目的：

注意以下几点：

1. 若多次使用subscribeOn()指定被观察者所在线程，则只有第一次是有效的
2. 若多次使用observeOn()指定观察者所在线程，则每指定一次都会进行一次线程调度

延迟操作

作用：在被观察者发送事件之前进行一些延迟的操作

delay()

作用：使得被观察者延迟一段时间再发送事件

delay()方法具有多个重载形式：

// 1. 指定延迟时间// 参数1：时间；参数2：时间单位delay(long delay,TimeUnit unit)// 2. 指定延迟时间 & 调度器// 参数1：时间；参数2：时间单位；参数3 ：线程调度器delay(long delay,TimeUnit unit,mScheduler scheduler)// 3. 指定延迟时间 & 错误延迟// 错误延迟，即：若存在Error事件，则如常执行，执行后再抛出错误异常// 参数1：时间；参数2 ：时间单位；参数3：错误延迟参数delay(long delay,TimeUnit unit,boolean delayError)// 4. 指定延迟时间 & 调度器 & 错误延迟// 参数1 ：时间；参数2：时间单位；参数3：线程调度器；参数4：错误延迟参数delay(long delay,TimeUnit unit,mScheduler scheduler,boolean delayError): 指定延迟多长时间并添加调度器，错误通知可以设置是否延迟

具体使用：

 public void delayRun() { print(df.format(new Date()) + "开始"); Observable.just(1, 2, 3) .delay(3, TimeUnit.SECONDS) // 延迟3s再发送，由于使用类似，所以此处不作全部展示 .subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { print(df.format(new Date()) + "订阅"); } @Override public void onNext(Integer value) { print(df.format(new Date()) + "-接收到了事件" + value); } @Override public void onError(Throwable e) { print(df.format(new Date()) + "-对Error事件作出响应"); } @Override public void onComplete() { print(df.format(new Date()) + "-对Complete事件作出响应"); } }); }

执行结果：

在事件的生命周期中操作

需求场景：在事件发送 & 接收的整个生命周期过程中进行操作，如发送事件前的初始化、发送事件后的回调请求等

do()

作用：在事件的生命周期中调用

具体的分很多小的操作符，如下图所示：

具体使用：

 public void doRun() { Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); emitter.onError(new NullPointerException()); emitter.onComplete(); } }).doOnEach(new Consumer>() { @Override public void accept(Notification integerNotification) throws Exception { print("doOnEach:" + integerNotification.toString()); } }).doOnNext(new Consumer() { @Override public void accept(Integer integer) throws Exception { print("doOnNext:" + integer); } }).doOnError(new Consumer() { @Override public void accept(Throwable throwable) throws Exception { print("doOnError:" + throwable.getMessage()); } }).doOnComplete(new Action() { @Override public void run() throws Exception { print("doOnComplete"); } }).doAfterNext(new Consumer() { @Override public void accept(Integer integer) throws Exception { print("doAfterNext:" + integer); } }).doOnTerminate(new Action() { @Override public void run() throws Exception { print("doOnTerminate"); } }).doAfterTerminate(new Action() { @Override public void run() throws Exception { print("doAfterTerminate"); } }).doOnSubscribe(new Consumer() { @Override public void accept(Disposable disposable) throws Exception { print("doOnSubscribe"); } }).doOnDispose(new Action() { @Override public void run() throws Exception { print("doOnDispose"); } }).doOnLifecycle(new Consumer() { @Override public void accept(Disposable disposable) throws Exception { print("doOnLifecycle-accept"); } }, new Action() { @Override public void run() throws Exception { print("doOnLifecycle-action"); } }).subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { print("onSubscribe"); } @Override public void onNext(Integer value) { print("接收到了事件" + value); } @Override public void onError(Throwable e) { print("对Error事件作出响应"); } @Override public void onComplete() { print("对Complete事件作出响应"); } }); }

运行结果：

错误处理

需求场景：发送事件时出现错误的情况下的处理机制

常见的错误处理机制有两种：

1. 发送数据

• 发送一个特殊事件以正常终止：onErrorReturn()
• 发送一个新的被观察者
• onErrorResumeNext()
• onExceptionResumeNext()

1. 重试

• 重试：retry()
• 让被观察者重新订阅：etryUntil()
• 将错误传递给另一个被观察者来决定是否重新订阅该被观察者：retryWhen()

onErrorReturn()

作用：捕捉错误事件，将错误事件转化为一个正常的事件，保证整个事件流不会出现错误事件。

具体使用：

public void onErrorRetrurnRun() { Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onError(new NullPointerException()); emitter.onNext(4); } }).onErrorReturn(new Function() { @Override public Integer apply(Throwable throwable) throws Exception { print("捕获异常:" + throwable.getMessage()); return 3; } }).subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { print("onSubscribe"); } @Override public void onNext(Integer value) { print("接收到了事件" + value); } @Override public void onError(Throwable e) { print("对Error事件作出响应"); } @Override public void onComplete() { print("对Complete事件作出响应"); } });}

运行结果：

可以看到，使用了onErrorReturn()操作符之后当被观察者发送异常事件后会被捕捉，并且观察者可以接收到onErrorReturn()操作符的返回值，这样可以保证整个事件流不会出现错误事件，但是，当onErrorReturn()操作符捕捉到错误事件后，被观察者在错误事件之后发送的事件仍然是不会被继续发送的，就像上面例子中发送的事件”4”还是不会被发送，但是最终会发送一个Complete事件。

onErrorResumeNext()

作用：捕捉错误事件，将错误事件转化为一个新的被观察者进行发送

基本使用：

public void onErrorResumeNextRun() { Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onError(new Throwable("错误")); } }).onErrorResumeNext(new Function>() { @Override public ObservableSource extends Integer> apply(Throwable throwable) throws Exception { //如果捕捉到Throwable，发送一个新的被观察者 return Observable.just(3, 4); } }).subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { print("onSubscribe"); } @Override public void onNext(Integer value) { print("接收到了事件" + value); } @Override public void onError(Throwable e) { print("对Error事件作出响应"); } @Override public void onComplete() { print("对Complete事件作出响应"); } });}

运行结果：

注意：onErrorResumeNext()只能捕捉到Throwable类型的错误事件，如果其捕捉到Exception类型的错误事件，会将错误事件传递给观察者的onError()方法。，如果想要捕捉Exception类型的错误事件，应该使用onExceptionResumeNext()，同样，若onExceptionResumeNext()捕捉到了Throwable类型的错误事件，则会将错误事件传递给观察者的onError()方法。

retry()

作用：重试，即当发生错误事件时让被观察者重新发送事件

具体使用：

public void retryRun() { Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onError(new Throwable("错误")); emitter.onNext(3); } //设置retry()中参数为3，表示最多允许被观察者重复发送3次 }).retry(3).subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { print("onSubscribe"); } @Override public void onNext(Integer value) { print("接收到了事件" + value); } @Override public void onError(Throwable e) { print("对Error事件作出响应"); } @Override public void onComplete() { print("对Complete事件作出响应"); } }); }

运行结果：

可以发现，当发送了错误事件之后，被观察者又重试了3次，知道第5次的时候才以错误事件终止。

retry()方法还有很多重载形式：

retry()：出现错误时，让被观察者重新发送数据，若一直错误，则一直重新发送retry(long time)：出现错误时，让被观察者重新发送数据(具备重试次数限制)，参数表示最多重试的次数retry(Predicate predicate) ：出现错误后，判断是否需要重新发送数据(若需要重新发送并且持续遇到错误，则持续重试)，参数表示判断是否重新发送数据的逻辑retry(new BiPredicate：出现错误后，判断是否需要重新发送数据(若需要重新发送 且持续遇到错误，则持续重试，参数表示判断是否需要重新发送数据的逻辑(传入当前重试次数 & 异常错误信息)retry(long time,Predicate predicate)：出现错误后，判断是否需要重新发送数据(具备重试次数限制)，参数表示重试次数以及判断逻辑

retryUntil()

作用：出现错误后，判断是否需要重新发送数据，若需要重新发送且持续遇到错误，则持续重试，作用类似于retry(Predicate predicate)

retryWhen()

作用：遇到错误时，将发生的错误传递给一个新的被观察者(Observable)，并决定是否需要重新订阅原始被观察者(Observable)以及发送事件

Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(ObservableEmitter e) throws Exception { e.onNext(1); e.onNext(2); e.onError(new Exception("发生错误了")); e.onNext(3); } }) // 遇到error事件才会回调 .retryWhen(new Function, ObservableSource>>() { @Override public ObservableSource> apply(@NonNull Observable throwableObservable) throws Exception { // 参数Observable中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型 // 返回Observable> = 新的被观察者 Observable(任意类型) // 此处有两种情况： // 1. 若 新的被观察者 Observable发送的事件 = Error事件，那么 原始Observable则不重新发送事件： // 2. 若 新的被观察者 Observable发送的事件 = Next事件 ，那么原始的Observable则重新发送事件： return throwableObservable.flatMap(new Function>() { @Override public ObservableSource> apply(@NonNull Throwable throwable) throws Exception { // 1. 若返回的Observable发送的事件 = Error事件，则原始的Observable不重新发送事件 // 该异常错误信息可在观察者中的onError()中获得 return Observable.error(new Throwable("retryWhen终止啦")); // 2. 若返回的Observable发送的事件 = Next事件，则原始的Observable重新发送事件(若持续遇到错误，则持续重试) // return Observable.just(1); } }); } }) .subscribe(new Observer() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Integer value) { Log.d(TAG, "接收到了事件"+ value ); } @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应" + e.toString()); // 获取异常错误信息 } @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } });

运行结果：

重复发送

需求场景：重复不断地发送被观察者事件

repeat()

作用：无条件地、重复发送被观察者事件，具备重载方法，可设置重复创建次数

repeatWhen()

作用：有条件地、重复发送 被观察者事件

注意：

1. 若新被观察者(Observable)返回1个Complete / Error事件，则不重新订阅 & 发送原来的 Observable
2. 若新被观察者(Observable)返回其余事件时，则重新订阅 & 发送原来的 `Observable