福州建站开发_地址信息采集平台_百度贴吧怎么发广告_搜索引擎优化的工具

资料连接

Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）

1. Merge & Zip操作符: 合并数据源

Android RxJava应用：合并数据源

2. Map & FlapMap & ConcatMap & Buffer: 变换操作符

Android RxJava应用：变换操作符

3. retry & retryUntil & retryWhen : 错误处理操作符

• retry
  retry(): 让被观察者重新发射数据，要是一直错误就一直发送了
  retry(BiPredicate)： interger是第几次重新发送，Throwable是错误的内容
  retry(long time): 最多让被观察者重新发射数据多少次
  retry(long time,Predicate predicate)： 最多让被观察者重新发射数据多少次，在predicate里面进行判断拦截 返回是否继续
  retry(Predicate predicate)： 在predicate里面进行判断拦截 返回是否继续
• retryUntil
  具体使用类似于retry（Predicate predicate），唯一区别：返回 true 则不重新发送数据事件。此处不作过多描述
• retryWhen
• 遇到错误时，将发生的错误传递给一个新的被观察者（Observable），并决定是否需要重新订阅原始被观察者（Observable）& 发送事件
  注意：
  retryWhen 通过 flatMap 返回的 Observable.just(1) 仅仅作为一个信号（同样会被onNext方法捕获），触发了原始的 Observable 重新订阅，从而重新执行 onNext(1) 和 onNext(2)

Observable.create(new ObservableOnSubscribe<Integer>() {@Overridepublic 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<?>>() {@Overridepublic 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<?>>() {@Overridepublic 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<Integer>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onNext(Integer value) {Log.d(TAG, "接收到了事件"+ value  );}@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应" + e.toString());// 获取异常错误信息}@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}});

4. Transformer & Compose 转换操作符

Transformer 在RxJava中的使用

• 定义
  Transformer 是一个接口，用于创建一个操作符，可以将一个 Observable 转换为另一个 Observable。通常，Transformer 是通过实现 ObservableTransformer<T, R> 接口来创建的。
• 使用场景
  当你需要在多个地方重用相同的操作链时，使用 Transformer 可以将一系列操作封装成一个可复用的单元。
• 代码

public class MyTransformer<T> implements ObservableTransformer<T, T> {@Overridepublic ObservableSource<T> apply(Observable<T> upstream) {return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).map(value -> value + " transformed");}
}// 使用
observable.compose(new MyTransformer<>()).subscribe(...);

5. 网络请求嵌套回调 FlatMap

网络请求嵌套回调
场景：需要进行嵌套网络请求：即在第1个网络请求成功后，继续再进行一次网络请求
解决方案：在第一个请求doOnNext方法后，flatMap 发起第二个请求

public class MainActivity extends AppCompatActivity {private static final String TAG = "Rxjava";// 定义Observable接口类型的网络请求对象Observable<Translation1> observable1;Observable<Translation2> observable2;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 步骤1：创建Retrofit对象Retrofit retrofit = new Retrofit.Builder().baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url.addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖).addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava.build();// 步骤2：创建 网络请求接口 的实例GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);// 步骤3：采用Observable<...>形式 对 2个网络请求 进行封装observable1 = request.getCall();observable2 = request.getCall_2();observable1.subscribeOn(Schedulers.io())               // （初始被观察者）切换到IO线程进行网络请求1.observeOn(AndroidSchedulers.mainThread())  // （新观察者）切换到主线程 处理网络请求1的结果.doOnNext(new Consumer<Translation1>() {@Overridepublic void accept(Translation1 result) throws Exception {Log.d(TAG, "第1次网络请求成功");result.show();// 对第1次网络请求返回的结果进行操作 = 显示翻译结果}}).observeOn(Schedulers.io())                 // （新被观察者，同时也是新观察者）切换到IO线程去发起登录请求// 特别注意：因为flatMap是对初始被观察者作变换，所以对于旧被观察者，它是新观察者，所以通过observeOn切换线程// 但对于初始观察者，它则是新的被观察者.flatMap(new Function<Translation1, ObservableSource<Translation2>>() { // 作变换，即作嵌套网络请求@Overridepublic ObservableSource<Translation2> apply(Translation1 result) throws Exception {// 将网络请求1转换成网络请求2，即发送网络请求2return observable2;}}).observeOn(AndroidSchedulers.mainThread())  // （初始观察者）切换到主线程 处理网络请求2的结果.subscribe(new Consumer<Translation2>() {@Overridepublic void accept(Translation2 result) throws Exception {Log.d(TAG, "第2次网络请求成功");result.show();// 对第2次网络请求返回的结果进行操作 = 显示翻译结果}}, new Consumer<Throwable>() {@Overridepublic void accept(Throwable throwable) throws Exception {System.out.println("登录失败");}});}
}

6. 网络请求出错重连 Retrywhen

网络请求出错重连

public class RxJavafixRetrofit2 extends AppCompatActivity {private static final String TAG = "RxJava";// 设置变量// 可重试次数private int maxConnectCount = 10;// 当前已重试次数private int currentRetryCount = 0;// 重试等待时间private int waitRetryTime = 0;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 步骤1：创建Retrofit对象Retrofit retrofit = new Retrofit.Builder().baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url.addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖).addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava.build();// 步骤2：创建 网络请求接口 的实例GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);// 步骤3：采用Observable<...>形式 对 网络请求 进行封装Observable<Translation> observable = request.getCall();// 步骤4：发送网络请求 & 通过retryWhen（）进行重试// 注：主要异常才会回调retryWhen（）进行重试observable.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {// 参数Observable<Throwable>中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {// 输出异常信息Log.d(TAG,  "发生异常 = "+ throwable.toString());/*** 需求1：根据异常类型选择是否重试* 即，当发生的异常 = 网络异常 = IO异常 才选择重试*/if (throwable instanceof IOException){Log.d(TAG,  "属于IO异常，需重试" );/*** 需求2：限制重试次数* 即，当已重试次数 < 设置的重试次数，才选择重试*/if (currentRetryCount < maxConnectCount){// 记录重试次数currentRetryCount++;Log.d(TAG,  "重试次数 = " + currentRetryCount);/*** 需求2：实现重试* 通过返回的Observable发送的事件 = Next事件，从而使得retryWhen（）重订阅，最终实现重试功能** 需求3：延迟1段时间再重试* 采用delay操作符 = 延迟一段时间发送，以实现重试间隔设置** 需求4：遇到的异常越多，时间越长* 在delay操作符的等待时间内设置 = 每重试1次，增多延迟重试时间1s*/// 设置等待时间waitRetryTime = 1000 + currentRetryCount* 1000;Log.d(TAG,  "等待时间 =" + waitRetryTime);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>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onNext(Translation result) {// 接收服务器返回的数据Log.d(TAG,  "发送成功");result.show();}@Overridepublic void onError(Throwable e) {// 获取停止重试的信息Log.d(TAG,  e.toString());}@Overridepublic void onComplete() {}});}
}

7. Concat & Merge 组合操作符

组合/合并操作符