深入浅出RxJava_02[订阅深入&异常处理]
来源：互联网 发布：网络纠纷管辖问题 编辑：程序博客网 时间：2024/05/24 07:39
本教程基于RxJava1.x版本进行全面讲解，后续课程将陆续更新,敬请关注…
8.可连接的被观察者
前几节提到的了响应用过程中的三个细节：被观察者 观察者 和订阅。 接下来这一节继续理解下订阅的其他知识点。
这里介绍一个叫做ConnectableObservable的可连接被观察者。一个可连接的Observable与普通的Observable差不多，除了这一点：可连接的Observable在被订阅时并不开始发射数据，只有在它的connect()被调用时才开始。用这种方法，你可以等所有的潜在订阅者都订阅了这个Observable之后才开始发射数据。
Publish
该操作符可以将普通的Observable转化成可连接的Observable。
可连接的Observable (connectable Observable)与普通的Observable差不多，不过它并不会在被订阅时开始发射数据，而是直到使用了Connect操作符时才会开始。用这种方法，你可以在任何时候让一个Observable开始发射数据。
RxJava中connect是ConnectableObservable接口的一个方法，使用publish操作符可以将一个普通的Observable转换为一个ConnectableObservable。
//创建了一个普通的Observable对象Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onNext(3); } });//将一个被观察者转换成一个可连接的被观察者ConnectableObservable<Integer> connectableObservable =observable.publish();//为可连接的被观察者订阅事件,但这里并不会马上发送事件connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); }});与普通的Observable对象订阅不同，上面的代码中并没直接调用Action1对象的call()方法。
Connect
可连接的Observable (connectable Observable)与普通的Observable差不多，不过它并不会在被订阅时开始发射数据，而是直到使用了Connect操作符时才会开始。用这个方法，你可以等待所有的观察者都订阅了Observable之后再开始发射数据。
//创建了一个普通的Observable对象Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onNext(3); } });//将一个被观察者转换成一个可连接的被观察者ConnectableObservable<Integer> connectableObservable =observable.publish();//为可连接的被观察者订阅事件,但这里并不会马上发送事件connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); }});//当调用可连接的被观察者connect()方法后 开始发送所有的数据。connectableObservable.connect(new Action1<Subscription>() { @Override public void call(Subscription subscription) { Log.i(TAG, "call: "+subscription); }});输出：
IT520: call: OperatorPublish$PublishSubscriber@20dce78IT520: call: 1IT520: call: 2IT520: call: 3RefCount
RefCount操作符可以让一个可连接的Observable转换为普通的Observable。
//创建了一个普通的Observable对象Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onNext(3); } });//将一个被观察者转换成一个可连接的被观察者ConnectableObservable<Integer> connectableObservable =observable.publish();//将一个可链接的被观察者转换成一个普通观察者Observable<Integer> integerObservable = connectableObservable.refCount();//为可连接的被观察者订阅事件,一订阅就马上发送数据并打印出 1 2 3...integerObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); }});Replay
保证所有的观察者收到相同的数据序列，即使它们在Observable开始发射数据之后才订阅.
先来看一个例子：
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onNext(3); } });ConnectableObservable<Integer> connectableObservable =observable.publish();connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call--1--: "+integer); }});connectableObservable.connect();connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call--2--: "+integer); }});输出：
com.m520it.rxjava I/IT520: call--1--: 1com.m520it.rxjava I/IT520: call--1--: 2com.m520it.rxjava I/IT520: call--1--: 3首先我们通过publish()将一个普通的Observable转换成ConnectableObservable。当调用connect()的时候，则connect()上面已经订阅的观察者会收到数据。而connect()后面订阅的观察者则无法接收到数据。 如果我们想让所有的观察者在调用connect()的时候同时接收到数据而跟订阅的顺序无关，则需要通过replay()。
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onNext(3); } });//这里将publish()改为replay()ConnectableObservable<Integer> connectableObservable =observable.replay();connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call--1--: "+integer); }});connectableObservable.connect();connectableObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call--2--: "+integer); }});输出：
com.m520it.rxjava I/IT520: call--1--: 1com.m520it.rxjava I/IT520: call--1--: 2com.m520it.rxjava I/IT520: call--1--: 3com.m520it.rxjava I/IT520: call--2--: 1com.m520it.rxjava I/IT520: call--2--: 2com.m520it.rxjava I/IT520: call--2--: 39.“冷Observable”&“热Observable”
前面我们提到，订阅的时候(如果观察者有发送数据的)，观察者有直接接收数据的，有等过了一段时间才接收数据的。
- 我们将一订阅观察者就马上能接收数据的观察者称之为“热Observable”。
- 如上面的ConnectableObservable就算被订阅后，也没能发送数据，只有调用connect()才能让观察者接收到数据。我们称该观察者为“冷Observable”
10.错误处理
很多操作符可用于对Observable发射的onError通知做出响应或者从错误中恢复
Catch操作符拦截原始Observable的onError通知，将它替换为其它的数据项或数据序列，让产生的Observable能够正常终止或者根本不终止。
RxJava将Catch实现为三个不同的操作符：
onErrorReturn
onErrorReturn方法返回一个镜像原有Observable行为的新Observable，后者会忽略前者的onError调用，不会将错误传递给观察者，作为替代，它会发发射一个特殊的项并调用观察者的onCompleted方法。
下面的代码发送1，2，3 并在发送的过程中模拟发送一个异常，只要有异常发送，onErrorReturn()就会被调用 并发送44.代码如下：
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onError(new NullPointerException("mock exception !")); subscriber.onNext(3); } }).onErrorReturn(new Func1<Throwable, Integer>() { @Override public Integer call(Throwable throwable) { return 44; } }).subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); } });输出：
com.m520it.rxjava I/IT520: call: 1com.m520it.rxjava I/IT520: call: 2com.m520it.rxjava I/IT520: call: 44onErrorResumeNext
让Observable在遇到错误时开始发射第二个Observable的数据序列。
下面的代码在发送的时候，模拟发送一个异常。接着onErrorResumeNext就会被调用 并开始发射新的Observable对象。
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onError(new NullPointerException("mock exception !")); subscriber.onNext(3); }}).onErrorResumeNext(new Func1<Throwable, Observable<? extends Integer>>() { @Override public Observable<? extends Integer> call(Throwable throwable) { Observable<Integer> innerObservable = Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(4); subscriber.onNext(5); } }); return innerObservable; }}).subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); }});输出：
com.m520it.rxjava I/IT520: call: 1com.m520it.rxjava I/IT520: call: 2com.m520it.rxjava I/IT520: call: 3com.m520it.rxjava I/IT520: call: 4com.m520it.rxjava I/IT520: call: 5onExceptionResumeNext
让Observable在遇到错误时继续发射后面的数据项。
//创建一个错误处理的Observable对象Observable<Integer> exceptionObserver = Observable .create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(55); subscriber.onNext(66); } });Observable .create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onError(new NullPointerException("mock exception !")); subscriber.onNext(3); } }) //上面的代码发送的过程中出现了异常,该方法就会被调用 并发射exceptionObserver .onExceptionResumeNext(exceptionObserver) .subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); } });输出：
com.m520it.rxjava I/IT520: call: 1com.m520it.rxjava I/IT520: call: 2com.m520it.rxjava I/IT520: call: 55com.m520it.rxjava I/IT520: call: 66Retry重试机制
如果原始Observable遇到错误，重新订阅它并期望它能正常终止。
RxJava中的实现为retry和retryWhen。
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(1); subscriber.onNext(2); subscriber.onError(new NullPointerException("mock exception !")); subscriber.onNext(3); } }) .retry(3)//重复3次订阅 .subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.i(TAG, "call: "+integer); } });类似的函数还有：
- Javadoc: retry()) 无论收到多少次onError通知，都会继续订阅并发射原始Observable。
- Javadoc: retry(long)) retry会最多重新订阅指定的次数，如果次数超了，不会尝试再次订阅
- Javadoc: retry(Func2))
- retryWhen
0 0
- 深入浅出RxJava_02[订阅深入&异常处理]
- java异常处理深入
- [深入RxBus]：异常处理
- Java&&深入理解异常处理
- Java异常处理-深入理解
- java异常处理机制的深入理解
- 深入探索Win32结构化异常处理
- 深入研究 Win32 结构化异常处理
- 深入探索Win32结构化异常处理
- 深入理解java异常处理机制
- 深入研究 Win32 结构化异常处理
- 企业库：异常处理模块深入研究
- 深入研究 Win32 结构化异常处理
- 深入探索Win32结构化异常处理
- 深入探索Win32结构化异常处理
- 深入探索Win32结构化异常处理
- 深入探索Win32结构化异常处理 .
- 深入理解java异常处理机制
- 字符编码
- 非 root 下安装 MySQL 5.6
- NuGet的简单使用
- SQL注入系列之PHP+Mysql手动注入(二)----字符型
- 27、函数指针
- 深入浅出RxJava_02[订阅深入&异常处理]
- Servlet3.0异步处理
- nefu 120 梅森素数 【Lucas-Lehmer】【miller_rabin】
- java main方法
- 快速选择
- 二叉树-你必须要懂！（二叉树相关算法实现-iOS）
- PDA开发从入门到精通(投稿公司报纸)
- hdu 1874 畅通工程续（迪杰斯特拉优先队列，floyd，spfa）
- [bash]总结
