美文网首页
RxJava基础五-错误处理操作符

RxJava基础五-错误处理操作符

作者: 清水杨杨 | 来源:发表于2019-05-02 16:41 被阅读0次

    此篇内容均是来自书籍《RxJava响应式编程》李衍顺 著

    3.5 错误处理操作符

    RxJava对错误的处理很方便,当有错误的时候就会调用Subscriber的onError方法将错误分发出去,由Subscriber自己来处理错误。这种处理错误的方式虽然方便,但也有缺点,就是每个Subscriber都要去定义如何处理错误,如果有100个Subscriber,就要定义100遍。这节来学习如何用错误处理操作符来集中处理错误。

    3.5.1 onErrorReturn

    onErrorReturn 操作符可在发生错误时,让Observable发送一个预先定义好的数据并停止继续发送数据。

    /**
         * onErrorReturn
         */
        private Observable<String> createObserver() {
            return Observable.create(new Observable.OnSubscribe<String>(){
    
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    for(int i= 1; i<=6; i++){
                        if(i<3){
                            subscriber.onNext("onNext:" + i);
                        } else {
                            subscriber.onError(new Throwable("Throw error"));
                        }
                    }
                }
            });
        }
        private Observable<String> onErrorReturnObserver(){
            return createObserver().onErrorReturn(new Func1<Throwable, String>() {
                @Override
                public String call(Throwable throwable) {
                    return "onErrorReturn";
                }
            });
        }
        private void onErrorReturnTest(){
            onErrorReturnObserver().subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    log("onErrorReturn-onCompleted");
                }
    
                @Override
                public void onError(Throwable e) {
                    log("onErrorReturn-onError:" + e.getMessage());
                }
    
                @Override
                public void onNext(String s) {
                    log("onErrorReturn-onNext:" + s);
                }
            });
        }
    输出结果:
    在发送出两个数据之后, onErrorReturn捕捉到了抛出的异常并返回了指定的字符串给订阅者,然后整个Observable发送数据的过程结束。
    onErrorReturn-onNext:onNext:1
    onErrorReturn-onNext:onNext:2
    onErrorReturn-onNext:onErrorReturn
    onErrorReturn-onCompleted
    

    3.5.2 onErrorResumeNext

    onErrorReturn操作符在有错误事件的时候回让Observable停止发送数据;而onErrorResumeNext在有错误发送的时候,会创建另外一个Observable来代替当前的Observable并继续发送数据,就好像错误并没有发生一样。

    private Observable<String> createObserver() {
            return Observable.create(new Observable.OnSubscribe<String>(){
    
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    for(int i= 1; i<=6; i++){
                        if(i<3){
                            subscriber.onNext("onNext:" + i);
                        } else {
                            subscriber.onError(new Throwable("Throw error"));
                        }
                    }
                }
            });
        }
    private Observable<String> onErrorReturnObserver(){
            return createObserver().onErrorReturn(new Func1<Throwable, String>() {
                @Override
                public String call(Throwable throwable) {
                    return "onErrorReturn";
                }
            });
        }
        private void onErrorReturnTest(){
            onErrorReturnObserver().subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    log("onErrorReturn-onCompleted");
                }
    
                @Override
                public void onError(Throwable e) {
                    log("onErrorReturn-onError:" + e.getMessage());
                }
    
                @Override
                public void onNext(String s) {
                    log("onErrorReturn-onNext:" + s);
                }
            });
        }
    订阅输出结果如下,在正常发送两个数据后产生错误,新创建的Observable继续发送7、8、9三个数字,然后整个数据发送过程结束
    onErrorResumeNext-onNext:onNext:1
    onErrorResumeNext-onNext:onNext:2
    onErrorResumeNext-onNext:7
    onErrorResumeNext-onNext:8
    onErrorResumeNext-onNext:9
    onErrorResumeNext-onCompleted
    

    3.5.3 onExceptionResumeNext

    onExceptionResumeNext操作符类似于onErrorResumeNext,不同之处在于其会对onError抛出的数据类型做判断--如果是Exception, 就会使用另一个Observable代替原Observable继续发送数据,否则将错误分发给Subscriber。

    /**
         * onExceptionResumeNext
         */
        private Observable<String> createObserver(final Boolean createException) {
            return Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    for(int i=1; i<=6; i++){
                        if(i<3){
                            subscriber.onNext("onNext:" + i);
                        } else if(createException){
                            subscriber.onError(new Exception("Exception"));
                        } else {
                            subscriber.onError(new Throwable("Throw error"));
                        }
                    }
                }
            });
        }
        private Observable<String> onExceptionResumeObserver(boolean isException) {
            return createObserver(isException).onExceptionResumeNext(Observable.just("7","8","9"));
        }
        private void onExceptionResumeNextTest(){
            onExceptionResumeObserver(true).subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    log("onException-true-onCompleted");
                }
    
                @Override
                public void onError(Throwable e) {
                    log("onException-true-onError:" + e.getMessage());
                }
    
                @Override
                public void onNext(String s) {
                    log("onException-true-onNext:" + s);
                }
            });
    
            onExceptionResumeObserver(false).subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    log("onException-false-onCompleted");
                }
    
                @Override
                public void onError(Throwable e) {
                    log("onException-false-onError:" + e.getMessage());
                }
    
                @Override
                public void onNext(String s) {
                    log("onException-false-onNext:" + s);
                }
            });
        }
    输出的结果如下,当错误的类型是Exception时, 在发送完1和2之后,onExceptionResumeNext会捕获到错误事件并且用新的Observable来继续发送数据7,8,9,最后整个过程正常结束;而当错误类型不是Exception时,onExceptionResumeNext将不会起任何作用,错误事件被直接分发给订阅者,整个过程非正常结束
    onException-true-onNext:onNext:1
    onException-true-onNext:onNext:2
    onException-true-onNext:7
    onException-true-onNext:8
    onException-true-onNext:9
    onException-true-onCompleted
    onException-false-onNext:onNext:1
    onException-false-onNext:onNext:2
    onException-false-onError:Throw error
    

    3.5.4 retry

    retry操作符在发送错误时会重新进行订阅, 而且可以重复多次,所以发送的数据可能会产生重复。但是有可能每次retry都会发送错误,从而造成不断订阅不断retry的死循环,这种情况下可以指定最大重复次数。如果retry达到了最大重复次数还有错误的话,就将错误返回给观察者。

    /**
         * retry
         */
        private Observable<Integer> createRetryObserver(){
            return Observable.create(new Observable.OnSubscribe<Integer>() {
                @Override
                public void call(Subscriber<? super Integer> subscriber) {
                    log("subscribe");
                    for(int i=0; i<3; i++){
                        if(i==2){
                            subscriber.onError(new Exception("Exception"));
                        } else {
                            subscriber.onNext(i);
                        }
                    }
                }
            });
        }
        private void retryTest(){
            createRetryObserver().retry(2).subscribe(new Subscriber<Integer>() {
                @Override
                public void onCompleted() {
                    log("retry-onCompleted");
                }
    
                @Override
                public void onError(Throwable e) {
                    log("retry-onError:"+ e.getMessage());
                }
    
                @Override
                public void onNext(Integer integer) {
                    log("retry-onNext:" + integer);
                }
            });
        }
    输出结果如下,Observable每次发送两个数据后会发送错误事件,从而导致重新订阅,在重新订阅了两次后, 错误事件最终被分发给了订阅者。
    subscribe
    retry-onNext:0
    retry-onNext:1
    subscribe
    retry-onNext:0
    retry-onNext:1
    subscribe
    retry-onNext:0
    retry-onNext:1
    retry-onError:Exception
    

    相关文章

      网友评论

          本文标题:RxJava基础五-错误处理操作符

          本文链接:https://www.haomeiwen.com/subject/skinnqtx.html