RxJava系列 (八) 异常处理型操作符

异常处理型操作符, 接收上游抛出的异常事件，做一下处理后，抛出到下游的onError()方法里去。

有三点需要注意：

1. 上游抛出异常后，不会直接抛给下游的onError()，需要经过异常处理操作符。不然会直接崩溃。

2. 如果需要有异常的情况，下游监听必须用完整版的Observer, 不能是简化版的Consumer。

3. 如果接收到异常，会中断上游后续发射的所有事件。

4. 在RxJava中，throw new Exception不是标准的形式，标准的是emitter.onError(new Error())

 

1. onErrorReturn

最先拦截到e.onError()并且可以给下游返回一个标识， 而throw new xxx拦截不到，反而整个程序崩溃。

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                //处理业务逻辑。
                boolean isHandled = false;

                //处理好后把处理正确与否告诉下游。
                if(isHandled){
                    emitter.onNext(200);
                }else {
                    emitter.onError(new IllegalAccessError());
                }
            }
        }).onErrorReturn(new Function<Throwable, Integer>() {
            @Override
            public Integer apply(Throwable throwable) throws Exception {
                return 400; //代表有错误，告诉下游监听者，onNext 400
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer o) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

2. onErrorResumeNext

和onErrorReturn区别不是很大。无非接受的是e.OnError, 返回的又是被观察者，所以可以再多次发射给下游的观察者接收。

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                //处理业务逻辑。
                boolean isHandled = false;

                //处理好后把处理正确与否告诉下游。
                if (isHandled) {
                    emitter.onNext(200);
                } else {
                    emitter.onError(new IllegalAccessError());
                }
            }
        }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
                return Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(400);
                        emitter.onNext(400);
                        emitter.onNext(400);
                        emitter.onNext(400);
                    }
                });
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer o) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

3. onExceptionResumeNext

这个操作符用的比较频繁。在发生throw型异常的时候， 能够被onExceptionResumeNext捕获。这种错误一定是可接受的，才这样使用，比如增加用户体验等。

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                for (int i = 0; i < 100; i++) {

                    if(i==5){
                        throw new IllegalArgumentException(); //不会崩溃，因为相当于onExceptionResumeNext catch住了。
                    }else {
                        emitter.onNext(i);
                    }
                }
            }
        }).onExceptionResumeNext(new ObservableSource<Integer>() {
            @Override
            public void subscribe(Observer<? super Integer> observer) {
                observer.onNext(404);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer o) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

4. retry

当发生异常的时候, 可以让上游根据条件不停的重试执行代码。根据条件，也可以在方法里设置重试次数。这个操作符用的也多的。

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                for (int i = 0; i < 100; i++) {

                    if (i == 5) {
                        throw new IllegalArgumentException(); //不会崩溃，因为相当于onExceptionResumeNext catch住了。
                    } else {
                        emitter.onNext(i);
                    }
                }
            }
        })
//示范一
//                .retry(new Predicate<Throwable>() {
//                    @Override
//                    public boolean test(Throwable throwable) throws Exception {
//                        return false;//代表不去重试。
//                    }
//                }
                // 示范二
//                .retry(1, new Predicate<Throwable>() {
//            @Override
//            public boolean test(Throwable throwable) throws Exception {
//                return false;//代表不去重试。
//            }
//        })
//        
                // 示范三，记录重试多少次。
                .retry(new BiPredicate<Integer, Throwable>() {
                    @Override
                    public boolean test(Integer integer, Throwable throwable) throws Exception {
                        Log.d("", "retry: 已经重试了：" +integer);
                        return true;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer o) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });