Rxjava从使用到原码的解析七: Rxjava异常型操作符

Rxjava异常型操作符

onErrorReturn

当发射onError事件的时候,就会拦截这个事件

onErrorResumeNext

跟onErrorReturn 差不多,只是onErrorResumeNext 返回的是一个被观察者,可以自己发射事件

onExceptionResumeNext

可以防止应用异常崩溃

 

retry

重试操作符,就是当上游发射了onError的时候,就会走到重试操作符里

onErrorReturn

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    if (i == 5) {
                        e.onError(new IllegalArgumentException("异常了..."));
                    } else {
                        e.onNext(i);
                    }
                }
                e.onComplete();
            }
        }).onErrorReturn(new Function<Throwable, Integer>() {
            @Override
            public Integer apply(Throwable throwable) throws Exception {
                Log.e(TAG, "onErrorReturn" + throwable.getMessage());
                return 404;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

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

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

就像上面代码,前面先会输出

onNext: 1

onNext: 2

onNext: 3

onNext: 4

当i==5的时候发送了一个onError事件,这个时候就会被onErrorReturn异常操作符给拦截输出

onErrorReturn异常了...

然后在他的apply方法里就会自动发射出一个onNext事件给下游接收,就会输出

onNext: 400  最后就是输出

onComplete

在这过程中不会输出onError下游事件

如果发射事件的时候直接异常了这个时候 程序会崩溃,

如果没有异常操作符的话,就会直接走到下游的onError

onExceptionResumeNext

 Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    if (i == 5) {
                        throw new Exception("解析数据出错");
                    } else {
                        e.onNext(i);
                    }
                }
                e.onComplete();
            }
        })
                .onExceptionResumeNext(new ObservableSource<Integer>() {
                    @Override
                    public void subscribe(Observer<? super Integer> observer) {
                        Log.e(TAG, "onExceptionResumeNext");
                        observer.onNext(400);
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer integer) {
                        Log.e(TAG, "onNext" + integer);
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError" );
                    }
                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete" );
                    }
                });

当在上游直接throw new Exception("解析数据出错");的时候,应用不会直接闪退,会直接到到异常操作符事件那.

 

retry

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    if (i == 5) {
                        throw new Exception("解析数据出错");
                    } else {
                        e.onNext(i);
                    }
                }
                e.onComplete();
            }
        })
                .retry(new Predicate<Throwable>() {
                    @Override
                    public boolean test(Throwable throwable) throws Exception {
                        Log.e(TAG, "retry: "+ throwable.getMessage());
                        return false;//如果返回false则不重试
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

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

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

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

他还有几个API

                .retry(4, new Predicate<Throwable>() {//代表会 重试4次
                    @Override
                    public boolean test(Throwable throwable) throws Exception {
                        return true;
                    }
                })

                .retry(new BiPredicate<Integer, Throwable>() {
                    @Override
                    public boolean test(Integer integer, Throwable throwable) throws Exception {
                        return true;//integer现在重试的是多少次                    }
                })

 

Rxjava理解一

Rxjava理解二

Rxjava理解三

Rxjava理解四

Rxjava理解五

Rxjava理解六