从零学习RxJava2.0-功能性操作符

最新推荐文章于 2023-05-16 15:30:14 发布

不融化的雪人

最新推荐文章于 2023-05-16 15:30:14 发布

阅读量512

点赞数

分类专栏：安卓 java

本文链接：https://blog.csdn.net/asffghfgfghfg1556/article/details/81227001

版权

安卓同时被 2 个专栏收录

63 篇文章 2 订阅

订阅专栏

java

7 篇文章 0 订阅

订阅专栏

功能性操作符

辅助被观察者（Observable）在发送事件时实现一些功能性需求
来张盗的图
来一一学习吧

订阅（连接被观察者 & 观察者）

对于这个这里就不再说了，太熟悉了

线程调度（切换被观察者和观察者的线程）

subscribeOn ， observeOn

代码

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "subscribe: 被观察者的线程 == " + Thread.currentThread().getName());
                emitter.onNext(1);
            }
        }).subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "onNext: " + integer);
                        Log.d(TAG, "onNext: 观察者的线程 == " + Thread.currentThread().getName());
                    }
                });

subscribe: 被观察者的线程 == RxNewThreadScheduler-1
onNext: 1
onNext: 观察者的线程 == RxNewThreadScheduler-2

看着就理解，不用解释
给一个参数表

类型	含义	应用场景
Schedulers.immediate()	当前线程 = 不指定线程	默认
AndroidSchedulers.mainThread()	Android主线程	操作UI
Schedulers.newThread()	常规新线程	耗时等操作
Schedulers.io()	io操作线程	网络请求、读写文件等io密集型操作
Schedulers.computation()	CPU计算操作线程	大量计算操作

延迟操作

delay

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

Observable.just(1).delay(1,TimeUnit.SECONDS).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });

这里就是延迟被观察者发送事件的时间，不再啰嗦

在事件的生命周期中操作

do

在某个事件的生命周期中调用
具体解释盗张图
代码

Observable.just(1).doAfterNext(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

            }
        }).doOnEach(new Consumer<Notification<Integer>>() {
            @Override
            public void accept(Notification<Integer> integerNotification) throws Exception {

            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

            }
        });

不想说，很容易理解

错误处理

先看onErrorReturn

遇到错误时，发送1个特殊事件 & 正常终止

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onError(new Throwable("这是错误"));
                emitter.onNext(2);
                emitter.onComplete();
            }
        }).onErrorReturn(new Function<Throwable, Integer>() {
            @Override
            public Integer apply(Throwable throwable) throws Exception {
                Log.d(TAG, "apply: 错误来了" +throwable.toString());
                return 666;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

log信息

onSubscribe: 
onNext: 1
apply: 错误来了java.lang.Throwable: 这是错误
onNext: 666
onComplete:

可以看到，错误成功的被处理，但也使得后期的事件不能再发送，当错误发生并处理以后，直接就到了onComplete方法，表示事件队列完结
接下来我根据上面的效果，说一下剩下的几个操作符的效果，这里就不细分析了

onErrorResumeNext

onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
                Log.d(TAG, "apply: 处理错误");
                return Observable.just(1);
            }
        }

我只贴关键代码，这个操作符的意思就是当onError调用时，将会被这个方法拦截，并使用一个新的被观察者去发送后续的事件

onErrorResumeNext

onExceptionResumeNext(new Observable<Integer>() {
            @Override
            protected void subscribeActual(Observer<? super Integer> observer) {
                observer.onNext(1);
                observer.onNext(2);
            }
        }

这个方法是当onError发生并且错误类型时Exception时，会触发此方法
与上者相比，因为Exception是Threwable的子类，所以这个操作符只能拦截Exception类型的错误，而上一个能拦截所有类型的错误

retry

重试，即当出现错误时，让被观察者（Observable）重新发射数据
拦截所有错误（Exception和Throwable）
因为它有五个重载方法，我在这里贴个表

类型	含义
retry（）	出现错误时，让被观察者重新发送数据若一直错误，则一直重新发送
retry（long time）	出现错误时，让被观察者重新发送数据（具备重试次数限制
retry（Predicate predicate）	出现错误后，判断是否需要重新发送数据（若需要重新发送& 持续遇到错误，则持续重试），参数为判断逻辑的内部类
retry（new BiPredicate）	出现错误调用，判断逻辑（传入当前重试次数 & 异常错误信息）
retry（long time,Predicate predicate）	出现错误后，判断是否需要重新发送数据（具备重试次数限制

- 这里我以第四个做代码示范

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onError(new Exception("这是错误"));
                emitter.onNext(2);
                emitter.onComplete();
            }
        }).retry(new BiPredicate<Integer, Throwable>() {
            @Override
            public boolean test(Integer integer, Throwable throwable) throws Exception {
                if(integer < 5){
                    return true;//返回true表示重新尝试
                }
                return false;//返回false表示不再尝试
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });

 accept: 1
 accept: 1
 accept: 1
 accept: 1
 accept: 1
reactivex.exceptions.OnErrorNotImplementedException: 这是错误
 at io.reactivex.internal.functions.Functions$OnErrorMissingConsumer.accept(Functions.java:704)
 at io.reactivex.internal.functions.Functions$OnErrorMissingConsumer.accept(Functions.java:701)

可以看到，他将被观察者的事件队列发送了五次，在第六次的时候停止了发送，并抛出了异常
其他的我就不贴了，基本都一样

retryUntil

出现错误后，判断是否需要重新发送数据
类似于retry（Predicate predicate）
唯一区别：返回 true 则不重新发送数据事件

retryWhen

遇到错误时，将发生的错误传递给一个新的被观察者（Observable），并决定是否需要重新订阅原始被观察者（Observable）& 发送事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(2);
                emitter.onError(new Exception("这是错误"));
            }
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {

                //当发生错误的时候，本来错误是从被观察者的subscribe方法传递到观察者的onError方法，
                // 但是到这里却被拦截，并将错误交给这个throwableObservable，然后调用FlatMap方法，
                //FlatMap方法是用来拦截事件并处理，处理完成还是要走到观察者的onError方法的，那么我们在这里通过FlatMap
                // 将错误包装成一个错误被观察者事件，然后发送，这样，因为我们发送的还是一个错误事件，所以onError还是被调用，
                //当然我们也可以在这里返回一个正常的被观察者
                return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Throwable throwable) throws Exception {
                        return Observable.error(new Throwable("retryWhen终止啦"));
                        //返回这种格式，代表回调我们观察者的onError方法
//                        return Observable.just(1);
                        //返回这种格式，代表原始的被观察者重新发送消息
                    }
                });
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

重复发送

重复不断地发送被观察者事件

repeat ， repeatWhen

repeat无条件地、重复发送被观察者事件，具备重载方法，可设置重复创建次数
repeatWhen，将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable），以此决定是否重新订阅 & 发送原来的 Observable
若新被观察者（Observable）返回1个Complete / Error事件，则不重新订阅 & 发送原来的 Observable
若新被观察者（Observable）返回其余事件时，则重新订阅 & 发送原来的 Observable

不融化的雪人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从零学习RxJava2.0-功能性操作符

功能性操作符辅助被观察者（Observable）在发送事件时实现一些功能性需求来张盗的图来一一学习吧订阅（连接被观察者 &amp; 观察者）subscribe对于这个这里就不再说了，太熟悉了线程调度（切换被观察者和观察者的线程）subscribeOn ， observeOn代码Observable.create(new Ob...
复制链接

扫一扫