最近在研究Android网络请求的相关框架，目前比较主流的就是RxJava结合Retrofit的使用，看了大神Carson_Ho对该框架的剖析，学习的同时也在此同步记录总结，后面用的时候可以直接查阅此文。
RxJava
RxJava是一个 基于事件流、实现异步操作的库，包含各种各样的操作符，其基于链式的调用方式可以完成丰富的功能需求，使用方便简单，深受大家的喜欢。
在这里，我总结了关于RxJava的多种操作符的使用，通过结合多种操作符即可完成大多数功能需求，这里介绍的类似于API一样的调用方式，每个操作符通过一个小案例实现，并在案例中描述了操作符的具体作用。
创建被观察者
| 字段 | 特点 |
|---|---|
| create | 最原始的创建被观察者的方式，最繁琐却能定义最复杂的事件 |
| just | 快速创建多个事件（小于10个） |
| fromArray | 从数组快速创建多个事件（可大于10个） |
| fromIterable | 通过集合创建事件（可多个） |
| empty | 仅发送Complete事件，直接通知完成 |
| error | 仅发送Error事件，直接通知异常 |
| never | 不发送任何事件 |
| defer | 直到有观察者订阅时，才动态创建被观察者对象 & 发送事件，保证事件是最新的。 |
| timer | 延迟发送事件 |
| interval，intervalRange | 周期性发送事件 |
| range | 发送指定范围的事件 |
变换事件
| 字段 | 特点 |
|---|---|
| map | 将被观察者发送的事件转换为任意的类型事件 |
| flatMap | 将被观察者发送的事件序列进行 拆分 & 单独转换，再合并成一个新的事件序列进行发送 |
| concatMap | 与FlatMap的 区别在于：拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序 |
| buffer | 定期从 被观察者需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送 |
组合操作符
| 字段 | 特点 |
|---|---|
| concat | 组合多个被观察者（小于4个）一起发送数据，合并后 按发送顺序串行执行 |
| concatArray | 组合多个被观察者（大于4个）一起发送数据，合并后 按发送顺序串行执行 |
| merge | 组合多个被观察者（小于4个）一起发送数据，合并后 按时间线并行执行 |
| mergeArray | 组合多个被观察者（大于4个）一起发送数据，合并后 按时间线并行执行 |
| concatArrayDelayError | 发生error事件时，等其他被观察者发送完事件之后再发送error事件 |
| zip | 合并多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送 |
| combineLatest | 与Zip的区别：Zip+ 按个数合并，即1对1合并；CombineLatest = 按时间合并，即在同一个时间点上合并 |
| reduce | 把被观察者需要发送的事件聚合成1个事件 & 发送 |
| collect | 将被观察者Observable发送的数据事件收集到一个数据结构里 |
| startWith | 在一个被观察者发送事件前，追加发送一些数据 / 一个新的被观察者 |
| count | 统计被观察者发送事件的数量 |
功能操作符
| 字段 | 特点 |
|---|---|
| delay | 使得被观察者延迟一段时间再发送事件 |
| doOnEach | 当Observable每发送1次数据事件就会调用1次 |
| doOnNext | 执行onNext事件前调用,这里已经可以拿到事件结果了 |
| doAfterNext | 执行onNext事件后调用 |
| doOnComplete | Observable正常发送事件完毕后调用 |
| doOnError | Observable发送错误事件时调用 |
| doOnSubscribe | 观察者订阅时调用 |
| doAfterTerminate | Observable发送事件完毕后调用，无论正常发送完毕 / 异常终止 |
| doFinally | 最后执行 |
| onErrorReturn | 遇到错误时，发送1个特殊事件 & 正常终止 |
| onErrorResumeNext | 遇到Throwable错误时，发送1个新的Observable |
| onExceptionResumeNext | 遇到Exception错误时，发送1个新的Observable |
| retry | 接收到 onError（）时，重新订阅 & 发送事件 |
| retryWhen | 遇到error事件才会回调 |
| repeat | 无条件地、重复发送 被观察者事件 |
| repeatWhen | 将原始 Observable 停止发送事件的标识（Complete() / Error())转换成1个 Object 类型数据传递给1个新被观察者，以此决定是否重新订阅 & 发送原来的 Observable |
在实现功能之前可以在此复习一下各操作符，然后结合功能组合操作符，最终实现自己想要的效果。
下面详细讲一下每个字段的使用，在这之前首先说明一下本次使用的RxJava的版本：
implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
引入包之后即可使用RxJava的字段，在这里我写了一个类RxJavaUtil，这里把每个字段的用法都简单写了一下，想体验一下使用效果的直接复制这个类，并在Activity中运行一下即可。这里主要参考的是Carson_Ho大神的RxJava系列讲解文章，再次感谢大佬的无私奉献。
public class RxJavaUtil {
private static final String TAG = RxJavaUtil.class.getSimpleName();
// <-----------------------------------创建操作符----------------------------------------------->
// Integer观察者，定义接收到事件后的处理
Observer observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
System.out.println("开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
System.out.println("接收到了事件"+ value);
}
@Override
public void onError(Throwable e) {
System.out.println("对Error事件作出响应");
}
@Override
public void onComplete() {
System.out.println("对Complete事件作出响应");
}
};
// Long观察者，延时监听会发送long value
Observer<Long> longObserver = new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
System.out.println("开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
System.out.println("接收到了事件"+ value);
}
@Override
public void onError(Throwable e) {
System.out.println("对Error事件作出响应");
}
@Override
public void onComplete() {
System.out.println("对Complete事件作出响应");
}
};
/**
* 1.定义好被观察者以及被订阅之后发送的事件
* 2.定义观察者以及接收到事件后的相应
* 3.订阅，可多次订阅，多次订阅则多次连接并多次触发响应
*/
public void createObservableByCreate() {
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
});
observable.subscribe(observer);
}
/**
* 快速创建Observable，与createObservableByCreate方法类似，只是创建Observable更为便捷
* 创建时传入整型1、2、3、4
* 在创建后就会发送这些对象，相当于执行了onNext(1)、onNext(2)、onNext(3)、onNext(4)
*
* 应用场景：快速创建 被观察者对象（Observable） & 发送10个以下事件
*/
public void createObservableByJust() {
// 创建时传入整型1、2、3、4
// 在创建后就会发送这些对象，相当于执行了onNext(1)、onNext(2)、onNext(3)、onNext(4)
Observable observable = Observable.just(1, 2, 3,4);
observable.subscribe(observer);
}
/**
* 通过数组创建Observable，与createObservableByJust类似，但可以传递更多的事件
*
* 应用场景：快速创建 被观察者对象（Observable） & 发送10个以上事件
*/
public void createObservableByArray() {
Integer[] items = {1,2,3,4,5,6};
Observable observable = Observable.fromArray(items);
observable.subscribe(observer);
}
/**
* 通过集合创建Observable，与createObservableByArray类似
*
* 应用场景：快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）
*/
public void createObservableByIterable() {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
Observable observable = Observable.fromIterable(list);
observable.subscribe(observer);
}
/**
* 用来测试的一些Observable
*/
public void createObservableForTest() {
// 该方法创建的被观察者对象发送事件的特点：仅发送Complete事件，直接通知完成
Observable emptyObservable = Observable.empty();
emptyObservable.subscribe(observer);
// 该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常
Observable errorObservable = Observable.error(new RuntimeException());
errorObservable.subscribe(observer);
// 该方法创建的被观察者对象发送事件的特点：不发送任何事件
Observable neverObservable = Observable.never();
neverObservable.subscribe(observer);
}
/**
* 通过 Observable工厂方法创建被观察者对象（Observable）
* 每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的
* 直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件
*
* 因为是在订阅时才创建，所以i值会取第2次的赋值
*/
int i;
public void createObservableByDefer() {
i = 10;
Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> call() throws Exception {
return Observable.just(i);
}
});
i = 100;
observable.subscribe(observer);
}
/**
* 延迟指定时间后，发送1个数值0（Long类型）
* 本质 = 延迟指定时间后，调用一次 onNext(0)
*/
public void createObservableByTimer() {
Observable observable = Observable.timer(2, TimeUnit.SECONDS);
observable.subscribe(longObserver);
}
/**
* 发送事件的特点：每隔指定时间就发送事件
* 发送的事件序列 = 从0开始、无限递增1的的整数序列
*/
public void createObservableByInterval() {
Observable observable = Observable.interval(1, 1, TimeUnit.SECONDS);
observable.subscribe(longObserver);
}
/**
* 发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据的数量
* a. 发送的事件序列 = 从0开始、无限递增1的的整数序列
* b. 作用类似于interval（），但可指定发送的数据的数量
*/
public void createObservableByIntervalRange() {
// 参数说明：
// 参数1 = 事件序列起始点；
// 参数2 = 事件数量；
// 参数3 = 第1次事件延迟发送时间；
// 参数4 = 间隔时间数字；
// 参数5 = 时间单位
Observable observable = Observable.intervalRange(3, 10, 2, 1, TimeUnit.SECONDS);
observable.subscribe(longObserver);
}
/**
* 发送事件的特点：连续发送 1个事件序列，可指定范围
* 作用类似于intervalRange（），但区别在于：无延迟发送事件
* 还有一个rangeLong方法，与该方法使用一致
*/
public void createObservableByRange() {
Observable observable = Observable.range(1, 3);
observable.subscribe(observer);
}
// <----------------------------------------------变换操作符------------------------------------->
// 接收转换后的事件
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
};
/**
* 对被观察者发送的每1个事件都通过指定的函数处理，从而变换成另外一种事件,即， 将被观察者发送的事件转换为任意的类型事件。
* 应用场景：数据类型转换
*/
@SuppressLint("CheckResult")
public void handleEventByMap() {
Observable<Integer> observable = Observable.just(1,2,3,4);
observable.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "变换前 ： " + integer + "变换后" + integer.toString();
}
}).subscribe(consumer);
}
/**
* 将被观察者发送的事件序列进行 拆分 & 单独转换，再合并成一个新的事件序列，最后再进行发送
*
* 应用场景：无序的将被观察者发送的整个事件序列进行变换
* 新合并生成的事件序列顺序是无序的，即 与旧序列发送事件的顺序无关
*/
@SuppressLint("CheckResult")
public void handleEventByFlatMap() {
Observable<Integer> observable = Observable.just(1,2,3,4);
observable.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("我是事件 " + integer + "拆分后的子事件" + i);
// 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
// 最终合并，再发送给被观察者
}
return Observable.fromIterable(list);
}
}).subscribe(consumer);
}
/**
* 与FlatMap（）的 区别在于：拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序
* 新合并生成的事件序列顺序是有序的，即 严格按照旧序列发送事件的顺序
*
* 应用场景：有序的将被观察者发送的整个事件序列进行变换
*/
@SuppressLint("CheckResult")
public void handleEventByConcatMap() {
Observable<Integer> observable = Observable.just(1,2,3,4);
observable.concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("我是事件 " + integer + "拆分后的子事件" + i);
// 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
// 最终合并，再发送给被观察者
}
return Observable.fromIterable(list);
}
}).subscribe(consumer);
}
/**
* 定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送
*
* 应用场景：缓存被观察者发送的事件
*/
public void handleEventByBuffer() {
Observable.just(1, 2, 3, 4, 5)
.buffer(3, 1) // 设置缓存区大小 & 步长
// 缓存区大小 = 每次从被观察者中获取的事件数量
// 步长 = 每次获取新事件的数量
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(List<Integer> stringList) {
//
System.out.println(" 缓存区里的事件数量 = " + stringList.size());
for (Integer value : stringList) {
System.out.println(" 事件 = " + value);
}
}
@Override
public void onError(Throwable e) {
System.out.println("对Error事件作出响应" );
}
@Override
public void onComplete() {
System.out.println("对Complete事件作出响应");
}
});
}
// <--------------------------------------------------组合/合并操作符--------------------------------->
/**
* 组合多个被观察者一起发送数据，合并后 按发送顺序串行执行
* 组合被观察者数量≤4个
*/
public void concatObservable() {
Observable.concat(Observable.just(1, 2, 3),
Observable.just(4, 5, 6),
Observable.just(7, 8, 9),
Observable.just(10, 11, 12))
.subscribe(observer);
}
/**
* 组合多个被观察者一起发送数据，合并后 按发送顺序串行执行
* 组合被观察者数量>4个
*/
public void concarArrayObservable() {
Observable.concatArray(Observable.just(1, 2, 3),
Observable.just(4, 5, 6),
Observable.just(7, 8, 9),
Observable.just(10, 11, 12),
Observable.just(13, 14, 15))
.subscribe(observer);
}
/**
* 组合多个被观察者一起发送数据，合并后 按时间线并行执行
* 组合被观察者数量≤4个
*/
public void mergeObservable() {
Observable.merge(
// 从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
// 从2开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS))
.subscribe(longObserver);
}
/**
* 组合多个被观察者一起发送数据，合并后 按时间线并行执行
* 组合被观察者数量>4个
*/
public void mergeArrayObservable() {
Observable.mergeArray(
Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(4, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(6, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(8, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(10, 3, 1, 1, TimeUnit.SECONDS))
.subscribe(longObserver);
}
/**
* 使用concat和merge操作符时
* 若其中一个Observable发出了onError事件，则会马上终止其他被观察者的事件发送
* 通过DelayError操作符，可以等其他被观察者发送完事件之后再发送error事件
*
* 下面演示了concatArrayDelayError的使用，concatDelayError,mergeDelayError,mergeArrayDelayError,combineLatestDelayError使用相同
*/
public void concatDelayErrorObservable() {
Observable.concatArrayDelayError(
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new NullPointerException()); // 发送Error事件，因为使用了concatDelayError，所以第2个Observable将会发送事件，等发送完毕后，再发送错误事件
emitter.onComplete();
}
}),
Observable.just(4, 5, 6))
.subscribe(observer);
}
/**
* 合并多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送
*
* 事件组合方式 = 严格按照原先事件序列 进行对位合并
* 最终合并的事件数量 = 多个被观察者（Observable）中数量最少的数量
*
* 尽管被观察者2的事件D没有事件与其合并，但还是会继续发送
* 若在被观察者1 & 被观察者2的事件序列最后发送onComplete()事件，则被观察者2的事件D也不会发送
*
* 应用场景：合并网络请求的发送，统一显示结果（RxJava+Retrofit）
*/
public void zipObservable() {
// <-- 创建第1个被观察者 -->
Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "被观察者1发送了事件1");
emitter.onNext(1);
// 为了方便展示效果，所以在发送事件后加入2s的延迟
Thread.sleep(1000);
Log.d(TAG, "被观察者1发送了事件2");
emitter.onNext(2);
Thread.sleep(1000);
Log.d(TAG, "被观察者1发送了事件3");
emitter.onNext(3);
emitter.onComplete();
}
}).subscribeOn(Schedulers.io()); // 设置被观察者1在工作线程1中工作
//<-- 创建第2个被观察者 -->
Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.d(TAG, "被观察者2发送了事件A");
emitter.onNext("A");
Thread.sleep(1000);
Log.d(TAG, "被观察者2发送了事件B");
emitter.onNext("B");
Thread.sleep(1000);
Log.d(TAG, "被观察者2发送了事件C");
emitter.onNext("C");
Log.d(TAG, "被观察者2发送了事件D");
emitter.onNext("D");
emitter.onComplete();
}
}).subscribeOn(Schedulers.newThread());// 设置被观察者2在工作线程2中工作
// 假设不作线程控制，则该两个被观察者会在同一个线程中工作，即发送事件存在先后顺序，而不是同时发送
//<-- 使用zip变换操作符进行事件合并 -->
// 注：创建BiFunction对象传入的第3个参数 = 合并后数据的数据类型
Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String string) throws Exception {
return integer + string;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String value) {
Log.d(TAG, "最终接收到的事件 = " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
/**
* 当两个Observables中的任何一个发送了数据后，将先发送了数据的Observables 的最新（最后）一个数据与
* 另外一个Observable发送的每个数据结合，最终基于该函数的结果发送数据
*
* 与Zip（）的区别：Zip（） = 按个数合并，即1对1合并；CombineLatest（） = 按时间合并，即在同一个时间点上合并
*/
@SuppressLint("CheckResult")
public void conbineLatestObservable() {
Observable.combineLatest(
// 第1个发送数据事件的Observable
Observable.just(1L, 2L, 3L),
// 第2个发送数据事件的Observable：从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
new BiFunction<Long, Long, Long>() {
@Override
public Long apply(Long o1, Long o2) throws Exception {
// o1 = 第1个Observable发送的最新（最后）1个数据
// o2 = 第2个Observable发送的每1个数据
Log.e(TAG, "合并的数据是： "+ o1 + " "+ o2);
return o1 + o2;
// 合并的逻辑 = 相加
// 即第1个Observable发送的最后1个数据 与 第2个Observable发送的每1个数据进行相加
}
}).subscribe(new Consumer<Long>() {
@Override
public void accept(Long s) throws Exception {
Log.e(TAG, "合并的结果是： "+s);
}
});
}
/**
* 把被观察者需要发送的事件聚合成1个事件 & 发送
* 聚合的逻辑根据需求撰写，但本质都是前2个数据聚合，然后与后1个数据继续进行聚合，依次类推
*/
@SuppressLint("CheckResult")
public void reduceObservable() {
Observable.just(1,2,3,4)
.reduce(new BiFunction<Integer, Integer, Integer>() {
// 在该复写方法中复写聚合的逻辑
@Override
public Integer apply(@NonNull Integer s1, @NonNull Integer s2) throws Exception {
Log.e(TAG, "本次计算的数据是： "+s1 +" 乘 "+ s2);
return s1 * s2;
// 本次聚合的逻辑是：全部数据相乘起来
// 原理：第1次取前2个数据相乘，之后每次获取到的数据 = 返回的数据x原始下1个数据每
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer s) throws Exception {
Log.e(TAG, "最终计算的结果是： "+s);
}
});
}
/**
* 将被观察者Observable发送的数据事件收集到一个数据结构里
*/
@SuppressLint("CheckResult")
public void collectObservable() {
Observable.just(1, 2, 3 ,4, 5, 6)
.collect(
// 1. 创建数据结构（容器），用于收集被观察者发送的数据
new Callable<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> call() throws Exception {
return new ArrayList<>();
}
// 2. 对发送的数据进行收集
}, new BiConsumer<ArrayList<Integer>, Integer>() {
@Override
public void accept(ArrayList<Integer> list, Integer integer)
throws Exception {
// 参数说明：list = 容器，integer = 后者数据
list.add(integer);
// 对发送的数据进行收集
}
}).subscribe(new Consumer<ArrayList<Integer>>() {
@Override
public void accept(@NonNull ArrayList<Integer> s) throws Exception {
Log.e(TAG, "本次发送的数据是： "+s);
}
});
}
/**
* 在一个被观察者发送事件前，追加发送一些数据 / 一个新的被观察者
*/
public void startWithObservable() {
// <-- 在一个被观察者发送事件前，追加发送一些数据 -->
// 注：追加数据顺序 = 后调用先追加
Observable.just(4, 5, 6)
.startWith(0) // 追加单个数据 = startWith()
.startWithArray(1, 2, 3) // 追加多个数据 = startWithArray()
.subscribe(observer);
// <-- 在一个被观察者发送事件前，追加发送被观察者 & 发送数据 -->
// 注：追加数据顺序 = 后调用先追加
Observable.just(4, 5, 6)
.startWith(Observable.just(1, 2, 3))
.subscribe(observer);
}
/**
* 统计被观察者发送事件的数量
*/
@SuppressLint("CheckResult")
public void countEvent() {
Observable.just(1, 2, 3, 4)
.count()
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "发送的事件数量 = "+aLong);
}
});
}
// <--------------------------------------------------功能操作符--------------------------------->
/**
* 使得被观察者延迟一段时间再发送事件
*/
public void delaySendEvent() {
// 指定延迟时间 & 调度器 & 错误延迟
// 参数1 = 延迟时间；参数2 = 时间单位；参数3 = 线程调度器；参数4 = 错误通知是否延迟
Observable.just(1, 2, 3)
.delay(3, TimeUnit.SECONDS, Schedulers.newThread(), true) // 延迟3s再发送，由于使用类似，所以此处不作全部展示
.subscribe(observer);
}
/**
* 在某个事件的生命周期中调用
*/
public void doOnObservable() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onError(new Throwable("发生错误了"));
}
})
// 1. 当Observable每发送1次数据事件就会调用1次
.doOnEach(new Consumer<Notification<Integer>>() {
@Override
public void accept(Notification<Integer> integerNotification) throws Exception {
Log.d(TAG, "doOnEach: " + integerNotification.getValue());
}
})
// 2. 执行onNext事件前调用,这里已经可以拿到事件结果了
.doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doOnNext: " + integer);
}
})
// 3. 执行onNext事件后调用
.doAfterNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doAfterNext: " + integer);
}
})
// 4. Observable正常发送事件完毕后调用
.doOnComplete(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doOnComplete: ");
}
})
// 5. Observable发送错误事件时调用
.doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.d(TAG, "doOnError: " + throwable.getMessage());
}
})
// 6. 观察者订阅时调用
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(@NonNull Disposable disposable) throws Exception {
Log.e(TAG, "doOnSubscribe: ");
}
})
// 7. Observable发送事件完毕后调用，无论正常发送完毕 / 异常终止
.doAfterTerminate(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doAfterTerminate: ");
}
})
// 8. 最后执行
.doFinally(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doFinally: ");
}
})
.subscribe(new Observer<Integer>() {
@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事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
/**
* 遇到错误时，发送1个特殊事件 & 正常终止
*/
public void onErrorReturn() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Throwable("发生错误了"));
}
})
.onErrorReturn(new Function<Throwable, Integer>() {
@Override
public Integer apply(@NonNull Throwable throwable) throws Exception {
// 捕捉错误异常
Log.e(TAG, "在onErrorReturn处理了错误: "+throwable.toString() );
return 666;
// 发生错误事件后，发送一个"666"事件，最终正常结束
}
})
.subscribe(observer);
}
/**
* 遇到错误时，发送1个新的Observable
*
* onErrorResumeNext（）拦截的错误 = Throwable；若需拦截Exception请用onExceptionResumeNext（）
* 若onErrorResumeNext（）拦截的错误 = Exception，则会将错误传递给观察者的onError方法
*/
public void onErrorResumeNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Throwable("发生错误了"));
}
})
.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> apply(@NonNull Throwable throwable) throws Exception {
// 1. 捕捉错误异常
Log.e(TAG, "在onErrorReturn处理了错误: "+throwable.toString() );
// 2. 发生错误事件后，发送一个新的被观察者 & 发送事件序列
return Observable.just(11,22);
}
})
.subscribe(observer);
}
/**
* 遇到错误时，发送1个新的Observable
*
* onExceptionResumeNext（）拦截的错误 = Exception；若需拦截Throwable请用onErrorResumeNext（）
* 若onExceptionResumeNext（）拦截的错误 = Throwable，则会将错误传递给观察者的onError方法
*/
public void onExceptionResumeNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Exception("发生错误了"));
}
})
.onExceptionResumeNext(new Observable<Integer>() {
@Override
protected void subscribeActual(Observer<? super Integer> observer) {
observer.onNext(11);
observer.onNext(22);
observer.onComplete();
}
})
.subscribe(observer);
}
/**
* 重试，即当出现错误时，让被观察者（Observable）重新发射数据
* 接收到 onError（）时，重新订阅 & 发送事件
* Throwable 和 Exception都可拦截
*
* 共五种重载方法
* <-- 1. retry（） -->
* // 作用：出现错误时，让被观察者重新发送数据
* // 注：若一直错误，则一直重新发送
*
* <-- 2. retry（long time） -->
* // 作用：出现错误时，让被观察者重新发送数据（具备重试次数限制
* // 参数 = 重试次数
*
* <-- 3. retry（Predicate predicate） -->
* // 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送& 持续遇到错误，则持续重试）
* // 参数 = 判断逻辑
*
* <-- 4. retry（new BiPredicate<Integer, Throwable>） -->
* // 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送 & 持续遇到错误，则持续重试
* // 参数 = 判断逻辑（传入当前重试次数 & 异常错误信息）
*
* <-- 5. retry（long time,Predicate predicate） -->
* // 作用：出现错误后，判断是否需要重新发送数据（具备重试次数限制
* // 参数 = 设置重试次数 & 判断逻辑
*
* retryUntil（）
* 具体使用类似于retry（Predicate predicate），唯一区别：返回 true 则不重新发送数据事件。
*/
public void retry() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Exception("发生错误了"));
e.onNext(3);
}
})
// 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送 & 持续遇到错误，则持续重试
// 参数 = 判断逻辑（传入当前重试次数 & 异常错误信息）
.retry(new BiPredicate<Integer, Throwable>() {
@Override
public boolean test(@NonNull Integer integer, @NonNull Throwable throwable) throws Exception {
// 捕获异常
Log.e(TAG, "异常错误 = "+throwable.toString());
// 获取当前重试次数
Log.e(TAG, "当前重试次数 = "+integer);
//返回false = 不重新重新发送数据 & 调用观察者的onError结束
//返回true = 重新发送请求（若持续遇到错误，就持续重新发送）
return true;
}
})
.subscribe(observer);
}
/**
* 遇到错误时，将发生的错误传递给一个新的被观察者（Observable），并决定是否需要重新订阅原始被观察者（Observable）& 发送事件
*/
public void retryWhen() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Exception("发生错误了"));
e.onNext(3);
}
})
// 遇到error事件才会回调
.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
// 参数Observable<Throwable>中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
// 返回Observable<?> = 新的被观察者 Observable（任意类型）
// 此处有两种情况：
// 1. 若 新的被观察者 Observable发送的事件 = Error事件，那么 原始Observable则不重新发送事件：
// 2. 若 新的被观察者 Observable发送的事件 = Next事件 ，那么原始的Observable则重新发送事件：
return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
@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(observer);
}
/**
* 无条件地、重复发送 被观察者事件
*/
public void repeat() {
Observable.just(1, 2, 3, 4)
.repeat(3) // 重复创建次数 =- 3次
.subscribe(observer);
}
/**
* 将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable），以此决定是否重新订阅 & 发送原来的 Observable
*
* 若新被观察者（Observable）返回1个Complete / Error事件，则不重新订阅 & 发送原来的 Observable
* 若新被观察者（Observable）返回其余事件时，则重新订阅 & 发送原来的 Observable
*/
public void repeatWhen() {
Observable.just(1,2,4).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
@Override
// 在Function函数中，必须对输入的 Observable<Object>进行处理，这里我们使用的是flatMap操作符接收上游的数据
public ObservableSource<?> apply(@NonNull Observable<Object> objectObservable) throws Exception {
// 将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable）
// 以此决定是否重新订阅 & 发送原来的 Observable
// 此处有2种情况：
// 1. 若新被观察者（Observable）返回1个Complete（） / Error（）事件，则不重新订阅 & 发送原来的 Observable
// 2. 若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Object throwable) throws Exception {
// 情况1：若新被观察者（Observable）返回1个Complete（） / Error（）事件，则不重新订阅 & 发送原来的 Observable
return Observable.empty();
// Observable.empty() = 发送Complete事件，但不会回调观察者的onComplete（）
// return Observable.error(new Throwable("不再重新订阅事件"));
// 返回Error事件 = 回调onError（）事件，并接收传过去的错误信息。
// 情况2：若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
// return Observable.just(1);
// 仅仅是作为1个触发重新订阅被观察者的通知，发送的是什么数据并不重要，只要不是Complete（） / Error（）事件
}
});
}
})
.subscribe(observer);
}
}
代码中为了少写点儿代码，很多地方是复用的Observer，但其实RxJava更多的用法是链式调用，在实际使用中可以结合各种字段并链式调用，但要注意调用时候的顺序，否则也容易出现各种意想不到的结果，比如线程错乱等。而且RxJava的魅力也在于其各种字段的链式组合，如果想要掌握RxJava，一定要各种字段的组合都尝试一遍，这样才能得心应手，否则拿到开发需求的时候，仅仅掌握各种字段用法，但不知如何组合调用，也是白学。
Retrofit
好了，RxJava的代码告一段落，下面讲一下Retrofit的使用，毕竟本文的最终目的是实现MVP+RxJava+Retrofit的结合。
Retrofit基于okhttp封装的网络请求框架, 网络请求的工作本质上是 OkHttp 完成，而 retrofit 仅负责网络请求接口的封装。
Retrofit优势，就是简洁易用,解耦,扩展性强,可搭配多种Json解析框架(例如Gson),另外还支持RxJava。
其他关于Retrofit的介绍在这里就不啰嗦了，百度一大堆，这里直接讲干货（Retrofit的使用）
首先引入Retrofit和Gson的支持，这样就可以使用Retrofit的方法以及Gson格式解析了。
implementation 'com.squareup.retrofit2:retrofit:2.1.0'
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'
Retrofit毕竟是网络请求，所以需要找一个可以发起网络请求并返回的网站，这里用采用有道翻译，无需注册开发者，直接可用。具体使用可以分为三步：
- 编写实体类，用于返回数据的解析
- 编写网络请求接口
- 通过Retrofit发起网络请求
下面简单讲解一下每一步，不详细描述，具体自行百度即可。
实体类
网络请求的返回结果一般是遵从某种格式的，比如json，xml，protobuff等，而实体类的编写就是为了将这些格式的结果转化，通过Adapter适配器可以将原始格式转化为我们的实体类，方便在程序中访问调用。
有道翻译的返回结果是Gson格式:
{
"type": "EN2ZH_CN",
"errorCode": 0,
"elapsedTime": 1,
"translateResult": [
[{
"src": "hello, world",
"tgt": "你好，世界"
}]
]
}
我们编写一个对应的实体类Translation
public class Translation {
private static final String TAG = Translation.class.getSimpleName();
private String type;
private int errorCode;
private int elapsedTime;
private List<List<TranslateResultBean>> translateResult;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getErrorCode() {
return errorCode;
}
public void setErrorCode(int errorCode) {
this.errorCode = errorCode;
}
public int getElapsedTime() {
return elapsedTime;
}
public void setElapsedTime(int elapsedTime) {
this.elapsedTime = elapsedTime;
}
public List<List<TranslateResultBean>> getTranslateResult() {
return translateResult;
}
public void setTranslateResult(List<List<TranslateResultBean>> translateResult) {
this.translateResult = translateResult;
}
public static class TranslateResultBean {
public String src;
public String tgt;
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
public String getTgt() {
return tgt;
}
public void setTgt(String tgt) {
this.tgt = tgt;
}
}
//定义 输出返回数据 的方法
public void show() {
Log.d(TAG, type);
Log.d(TAG, errorCode + "");
Log.d(TAG, elapsedTime + "");
Log.d(TAG, translateResult.get(0).get(0).src + ":" + translateResult.get(0).get(0).tgt);
}
@Override
public String toString() {
return "Translation{" +
"type='" + type + '\'' +
", errorCode=" + errorCode +
", elapsedTime=" + elapsedTime +
", translateResult=" + translateResult.get(0).get(0).tgt +
'}';
}
}
网络请求接口
通过标签来编写网络请求接口，标签众多，这里将用的比较多的标签列举了一遍，并在代码中做了详细说明。其他标签需要用到的时候可以自行查阅，用法一致，不多赘述。
public interface IGetRequest {
/**
* Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
* 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
* getCall()是接受网络请求数据的方法
*
* 这里等同于 @GET("translate?doctype=json&type=AUTO&i=keyword")
* @Path 标签可以动态设置url路径中的信息， @Query标签可以动态设置Get请求的参数信息
*/
@GET("{translate}?doctype=json&type=AUTO")
Call<Translation> getCall(@Path("translate") String translate, @Query("i") String keyword);
/**
* 这里与上面不同的地方在于字段采用map的方式填充，上面用Query的方式是一个字段一个字段的填充
* 如果@Get标签后没有跟url，可以在参数中动态设置url，这样的接口具有很大的通用性
*/
@GET
Call<Translation> getCall(@Url String url, @QueryMap HashMap<String, String> map);
/**
* 通过Post发送请求，用法与Get类似，只不过把标签换成了@Field
*/
@POST("translate")
@FormUrlEncoded
Call<Translation> postCall(@Field("doctype") String docType, @Field("type") String type, @Field("i") String i);
@POST("translate")
@FormUrlEncoded
Call<Translation> postCall(@FieldMap HashMap<String, String> map);
/**
* 替换@GET、@POST、@PUT、@DELETE、@HEAD注解的作用及更多功能拓展
*
* method：网络请求的方法（区分大小写）
* path：网络请求地址路径
* hasBody：是否有请求体
*/
@HTTP(method = "GET", path = "{translate}?doctype=json&type=AUTO&i=keyword", hasBody = false)
Call<Translation> httpCall(@Path("translate") String translate);
}
Retrofit请求
Retrofit的主要工作是配置网络请求的参数，包括请求地址，结果适配器，请求参数，结果处理回调等。需要注意，这里的参数配置要与网络请求接口配合，具体需要什么参数，怎么输入参数都是在接口中定义好的，Retrofit中的参数配置更多是执行接口的定义，所以接口的定义至关重要，这里举几个例子说明一下详细用法。
/**
* Get请求，异步返回,这里用Query标签填充字段
*/
private void getQueryRequestByCallback() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
IGetRequest request = retrofit.create(IGetRequest.class);
request.getCall("translate", "中国").enqueue(new Callback<Translation>() {
@Override
public void onResponse(Call<Translation> call, Response<Translation> response) {
response.body().show();
}
@Override
public void onFailure(Call<Translation> call, Throwable t) {
Log.e(TAG, t.getMessage() + "连接失败");
}
});
}
/**
* Get请求，异步返回,这里用QueryMap标签填充字段
*/
private void getQueryMapRequestByCallback() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
IGetRequest request = retrofit.create(IGetRequest.class);
HashMap<String, String> map = new HashMap<>();
map.put("doctype", "json");
map.put("type", "AUTO");
map.put("i", "美国");
request.getCall("translate", map).enqueue(new Callback<Translation>() {
@Override
public void onResponse(Call<Translation> call, Response<Translation> response) {
response.body().show();
}
@Override
public void onFailure(Call<Translation> call, Throwable t) {
Log.e(TAG, "连接失败");
}
});
}
/**
* Post请求，异步返回,这里用Field标签填充字段，用法与Get类似
*/
private void postFieldRequestByCallback() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
IGetRequest request = retrofit.create(IGetRequest.class);
Call<Translation> call = request.postCall("json", "AUTO", "韩国");
call.enqueue(new Callback<Translation>() {
@Override
public void onResponse(Call<Translation> call, Response<Translation> response) {
response.body().show();
}
@Override
public void onFailure(Call<Translation> call, Throwable t) {
Log.e(TAG, "连接失败");
}
});
}
/**
* Get请求，异步返回,这里用FieldMap标签填充字段,用法与Get类似
*/
private void postFieldMapByCallback() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build();
HashMap<String, String> map = new HashMap<>();
map.put("doctype", "json");
map.put("type", "AUTO");
map.put("i", "日本");
IGetRequest call = retrofit.create(IGetRequest.class);
call.postCall(map).enqueue(new Callback<Translation>() {
@Override
public void onResponse(Call<Translation> call, Response<Translation> response) {
response.body().show();
}
@Override
public void onFailure(Call<Translation> call, Throwable t) {
Log.e(TAG, "连接失败");
}
});
}
/**
* 通过http标签发起请求
*/
private void httpRequestByCallback() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
IGetRequest request = retrofit.create(IGetRequest.class);
request.httpCall("translate").enqueue(new Callback<Translation>() {
@Override
public void onResponse(Call<Translation> call, Response<Translation> response) {
response.body().show();
}
@Override
public void onFailure(Call<Translation> call, Throwable t) {
Log.e(TAG, "连接失败");
}
});
}
/**
* 同步返回，其他用法类似，不再举例
*/
private void postFieldMapBySync() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build();
HashMap<String, String> map = new HashMap<>();
map.put("doctype", "json");
map.put("type", "AUTO");
map.put("i", "日本");
IGetRequest call = retrofit.create(IGetRequest.class);
try {
Response<Translation> response = call.postCall(map).execute();
response.body().show();
} catch (IOException e) {
e.printStackTrace();
}
}
至此，RxJava和Retrofit的基础使用基本讲完了，下面进入本文的最终目标，MVP+Retrofit+RxJava结合案例。
MVP+RxJava+Retrofit
案例也很简单，采用的还是有道的网络请求，实现的也就是翻译功能，需求如下：
- 正常输入文本，可以自动识别出中英文并自动翻译出结果
- 网络请求失败时，自动重连并发起请求，并避免无限重连，有合理的重连机制
- 在重连时通过缓冲条展示，避免界面处于无反应状态
- 多次请求失败后，给出失败原因
MVP应该也不需要介绍，也没啥好说的，直接上代码吧：
首先要引入各种支持
// 此处一定要注意使用RxJava2的版本
implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
// Android 支持 Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.1.0'
// 衔接 Retrofit & RxJava
// 此处一定要注意使用RxJava2的版本
implementation 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
// 支持Gson解析
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'
看一下项目目录
Translation
这个在上面已经写过了，和上面的一样，就不说了
model
总共就三个类，IMvpModel定义获取网络请求的接口
public interface IMvpModel {
void getTranslation(String keyword, OnResultCallback callback);
}
MvpModelImpl是IMvpModel的实现，通过Retrofit和RxJava的结合获取网络请求结果，其中也处理了网络请求的重连机制以及重连时的UI缓冲机制，具体的细节可以自己运行调试一下，并没有什么复杂的逻辑。
public class MvpModelImpl implements IMvpModel {
private static final String TAG = MvpModelImpl.class.getSimpleName();
private static final String URL_YOUDAO = "http://fanyi.youdao.com/";
Retrofit retrofit;
int maxConnectCount = 5; // 可重试次数
int currentRetryCount = 0; // 当前已重试次数
int waitRetryTime = 0; // 重试等待时间
public MvpModelImpl() {
this.retrofit = RetrofitFactory.getInstance().createRetrofit(URL_YOUDAO);
}
@Override
public void getTranslation(String keyword, final OnResultCallback callback) {
retrofit.create(IGetRequest.class)
.getResult(keyword)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
// 参数Observable<Throwable>中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {
Log.d(TAG, "发生异常 = "+ throwable.toString());
if (throwable instanceof IOException){
Log.d(TAG, "属于IO异常，需重试" );
if (currentRetryCount < maxConnectCount){
// 记录重试次数
currentRetryCount++;
Log.d(TAG, "重试次数 = " + currentRetryCount);
// 设置等待时间
waitRetryTime = 1000 + currentRetryCount* 1000;
Log.d(TAG, "等待时间 =" + waitRetryTime);
// 通知UI展示缓冲条
callback.onRetryed(currentRetryCount);
return Observable.just(1).delay(waitRetryTime, TimeUnit.MILLISECONDS);
}else{
// 若重试次数已 > 设置重试次数，则不重试
// 通过发送error来停止重试（可在观察者的onError（）中获取信息）
return Observable.error(new Throwable("重试次数已超过设置次数 = " +currentRetryCount + "，不再重试"));
}
}
// 若发生的异常不属于I/O异常，则不重试
// 通过返回的Observable发送的事件 = Error事件 实现（可在观察者的onError（）中获取信息）
else{
return Observable.error(new Throwable("发生了非网络异常（非I/O异常）"));
}
}
});
}
}).subscribeOn(Schedulers.io()) // 切换到IO线程进行网络请求
.observeOn(AndroidSchedulers.mainThread()) // 切换回到主线程 处理请求结果
.subscribe(new Observer<Translation>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Translation result) {
// 通知界面显示结果
callback.onSuccess(result);
}
@Override
public void onError(Throwable e) {
// 通知界面请求失败
callback.onError(e);
}
@Override
public void onComplete() {
}
});
}
}
/**
* 与Presenter层交互的接口
*/
public interface OnResultCallback {
// 请求成功
void onSuccess(Translation translation);
// 尝试重连
void onRetryed(int count);
// 请求失败
void onError(Throwable throwable);
}
Presenter
很简单，View和Model层的衔接，没啥好说的
public interface IMvpPresenter {
void getTranslation(String keyword);
}
public class MvpPresenterImpl implements IMvpPresenter {
private static final String TAG = MvpPresenterImpl.class.getSimpleName();
private IMvpModel model;
private IView view;
public MvpPresenterImpl(IView view) {
this.view = view;
this.model = new MvpModelImpl();
}
@Override
public void getTranslation(String keyword) {
model.getTranslation(keyword, new OnResultCallback() {
@Override
public void onSuccess(Translation translation) {
view.showResult(translation);
}
@Override
public void onRetryed(int count) {
Log.d(TAG, "onRetryed: 重试了" + count + "次了");
view.showProgress(true);
}
@Override
public void onError(Throwable throwable) {
Log.e(TAG, "onError: " + throwable.getMessage() );
view.showError(throwable);
}
});
}
}
View
public interface IView {
void showResult(Translation result);
void showError(Throwable throwable);
void showProgress(boolean isShow);
}
public class MvpActivity extends AppCompatActivity implements IView, View.OnClickListener {
private static final String TAG = MvpActivity.class.getSimpleName();
private IMvpPresenter presenter;
private Button testBt;
private EditText contextEdit;
private TextView tv_result;
private ProgressBar progressBar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mvp);
initData();
initView();
}
@SuppressLint("HandlerLeak")
private void initData() {
presenter = new MvpPresenterImpl(this);
}
private void initView() {
testBt = findViewById(R.id.bt_test);
testBt.setOnClickListener(this);
contextEdit = findViewById(R.id.edit_context);
tv_result = findViewById(R.id.tv_result);
progressBar = findViewById(R.id.progress_bar);
}
@Override
public void showResult(Translation result) {
tv_result.setText("翻译结果 ： " + result.getTranslateResult().get(0).get(0).getTgt());
showProgress(false);
}
@Override
public void showError(Throwable throwable) {
tv_result.setText("获取翻译结果失败，请检查网络是否连接正常!");
showProgress(false);
}
@Override
public void showProgress(boolean isShow) {
progressBar.setVisibility(isShow ? View.VISIBLE : View.GONE);
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.bt_test:
presenter.getTranslation(contextEdit.getText().toString());
break;
}
}
}
布局文件
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.skydianshi.mvp.view.MvpActivity">
<Button
android:id="@+id/bt_test"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="开始翻译"/>
<EditText
android:id="@+id/edit_context"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="请在此处输入要翻译的文本"
android:layout_marginTop="20dp"/>
<TextView
android:id="@+id/tv_result"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="翻译结果："
android:textSize="24sp"
android:layout_marginTop="20dp"/>
<ProgressBar
android:id="@+id/progress_bar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:indeterminate="false"
android:visibility="gone"/>
</LinearLayout>
Retrofit
Retrofit的请求接口，跟上面讲Retrofit的时候讲的差不多
public interface IGetRequest {
@GET("translate?doctype=json&type=AUTO")
Observable<Translation> getResult(@Query("i") String i);
}
Retrofit工厂类
public class RetrofitFactory {
private static RetrofitFactory retrofitFactory;
public static RetrofitFactory getInstance() {
if (retrofitFactory == null) {
synchronized (RetrofitFactory.class) {
if (retrofitFactory == null) {
retrofitFactory = new RetrofitFactory();
}
}
}
return retrofitFactory;
}
public Retrofit createRetrofit(String url) {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(url)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build();
return retrofit;
}
}
总结
好了，至此本文基本结束了，总结一下，总共讲了以下几点：
- RxJava的基本使用
- Retrofit的基本使用
- MVP+RxJava+Retrofit的简单案例
之前项目中用的都是MVVM的架构，这次改用MVP来结合还有点不适应，需要定义的接口比较多，但总体感觉逻辑还是清晰一些的，由于不熟悉，文中定有诸多错误，但从实现功能的角度上来看算是完成了最初的设想，适合初学者速成，但要精通还需很多的沉淀。但从目前主流应用来看，主要的应用场景也就是本文所说的网络请求，因此把网络请求这方面理通理顺，应对普通的开发应该还是足够的，希望本文能对你有所帮助。
也希望大佬能不吝赐教文中的有误之处，感谢！
最后看一下demo的效果吧！
930
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
