rxjava：错误处理操作符（2）： onErrorReturn 、 onErrorResumeNext 、onExceptionResumeNext

参考:

[Android开发] RxJava2之路七 - 错误处理操作符例子Demo

RX操作符之错误处理（catch[onErrorReturn、onErrorResumeNext、onExceptionResumeNext]、retry、retryWhen）

catch[onErrorReturn、onErrorResumeNext、onExceptionResumeNext]
从onError通知中恢复发射数据。
Catch操作符拦截原始Observable的onError通知，将它替换为其它的数据项或数据序列，
让产生的Observable能够正常终止或者根本不终止。

onErrorReturn

让Observable遇到错误（Throwable、Error、Exception）时发射一个特殊的项并且正常终止。

//走onComplete
public void onErrorReturn1() {
    Observable.create(getObservableOnSubscribeThrowable())
            .subscribeOn(Schedulers.newThread())
            .onErrorReturn(new Function<Throwable, String>() {
                @Override
                public String apply(@NonNull Throwable throwable) {
                    System.out.println("在onErrorReturn处理了======" + throwable.toString());
                    //拦截到错误之后，返回一个结果发射，然后就正常结束了。
                    return "this is an error observable --> onErrorReturn";
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//在onErrorReturn处理了======java.lang.Throwable: 出现错误了
//onNext s================ this is an error observable --> onErrorReturn
//onComplete================




//走onComplete
public void onErrorReturn2() {
    Observable.create(getObservableOnSubscribeError())
            .subscribeOn(Schedulers.newThread())
            .onErrorReturn(new Function<Throwable, String>() {
                @Override
                public String apply(@NonNull Throwable throwable) {
                    System.out.println("在onErrorReturn处理了======" + throwable.toString());
                    //拦截到错误之后，返回一个结果发射，然后就正常结束了。
                    return "this is an error observable --> onErrorReturn";
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//在onErrorReturn处理了======java.lang.Error: 出现错误了
//onNext s================ this is an error observable --> onErrorReturn
//onComplete================




//走onComplete
public void onErrorReturn3() {
    Observable.create(getObservableOnSubscribeException())
            .subscribeOn(Schedulers.newThread())
            .onErrorReturn(new Function<Throwable, String>() {
                @Override
                public String apply(@NonNull Throwable throwable) {
                    System.out.println("在onErrorReturn处理了======" + throwable.toString());
                    //拦截到错误之后，返回一个结果发射，然后就正常结束了。
                    return "this is an error observable --> onErrorReturn";
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//在onErrorReturn处理了======java.lang.Exception: 出现错误了
//onNext s================ this is an error observable --> onErrorReturn
//onComplete================ 

onErrorResumeNext

让Observable在遇到错误（Throwable、Error、Exception）时开始发射第二个Observable的数据序列。

//走onComplete
public void onErrorResumeNext1() {
    Observable.create(getObservableOnSubscribeThrowable())
            .subscribeOn(Schedulers.newThread())
            .onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
                @Override
                public ObservableSource<? extends String> apply(@NonNull Throwable throwable) {
                    System.out.println("--在onErrorResumeNext处理了======"  
                    								+ throwable.toString());
                    //拦截到错误之后，重新定义了被观察者
                    return Observable.just("--重新定义了被观察者");
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//--在onErrorResumeNext处理了======java.lang.Throwable: 出现错误了
//onNext s================ --重新定义了被观察者
//onComplete================



//走onComplete
public void onErrorResumeNext2() {
    Observable.create(getObservableOnSubscribeError())
            .subscribeOn(Schedulers.newThread())
            .onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
                @Override
                public ObservableSource<? extends String> apply(@NonNull Throwable throwable) {
                    System.out.println("--在onErrorResumeNext处理了======" 
                    							+ throwable.toString());
                    //拦截到错误之后，重新定义了被观察者
                    return Observable.just("--重新定义了被观察者");
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//--在onErrorResumeNext处理了======java.lang.Error: 出现错误了
//onNext s================ --重新定义了被观察者
//onComplete================



//走onComplete
public void onErrorResumeNext3() {
    Observable.create(getObservableOnSubscribeException())
            .subscribeOn(Schedulers.newThread())
            .onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
                @Override
                public ObservableSource<? extends String> apply(@NonNull Throwable throwable) {
                    System.out.println("--在onErrorResumeNext处理了======" 
                    								+ throwable.toString());
                    //拦截到错误之后，重新定义了被观察者
                    return Observable.just("--重新定义了被观察者");
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//--在onErrorResumeNext处理了======java.lang.Exception: 出现错误了
//onNext s================ --重新定义了被观察者
//onComplete================ 

onExceptionResumeNext

和onErrorResumeNext类似，
onExceptionResumeNext方法返回一个镜像原有Observable行为的新Observable，
也使用一个备用的Observable，

不同的是，
如果onError收到的Throwable不是一个Exception，
它会将错误传递给观察者的onError方法，不会使用备用的Observable。

// Throwable 走 onError
public void onExceptionResumeNext1() {
    Observable.create(getObservableOnSubscribeThrowable())
            .subscribeOn(Schedulers.newThread())
            .onExceptionResumeNext(new Observable<String>() {
                @Override
                protected void subscribeActual(Observer<? super String> observer) {
                    System.out.println("--在onExceptionResumeNext处理了======");
                    observer.onNext("--错误替换的消息");
                    observer.onComplete();
                }
            })
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//onError e============= java.lang.Throwable: 出现错误了



// error 走 onError
public void onExceptionResumeNext2() {
    Observable.create(getObservableOnSubscribeError())
            .subscribeOn(Schedulers.newThread())
            .onExceptionResumeNext(Observable.just("occur an error1", "occur an error2"))
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//onError e============= java.lang.Error: 出现错误了



// exception 可以正常结束 ， 走 onComplete
public void onExceptionResumeNext3() {
    Observable.create(getObservableOnSubscribeException())
            .subscribeOn(Schedulers.newThread())
            .onExceptionResumeNext(Observable.just("occur an error1", "occur an error2"))
            .subscribe(getObserver());
}
//onNext s================ 0
//onNext s================ 1
//onNext s================ occur an error1
//onNext s================ occur an error2
//onComplete================ 

测试用的 Observable 和 Observer

private ObservableOnSubscribe<String> getObservableOnSubscribeThrowable() {
    return new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            for (int i = 0; i <= 3; i++) {
                if (i == 2) {
                    e.onError(new Throwable("出现错误了"));
                } else {
                    e.onNext(i + "");
                }
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            e.onComplete();
        }
    };
}

private ObservableOnSubscribe<String> getObservableOnSubscribeException() {
    return new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            for (int i = 0; i <= 3; i++) {
                if (i == 2) {
                    e.onError(new Exception("出现错误了"));
                } else {
                    e.onNext(i + "");
                }
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            e.onComplete();
        }
    };
}

private ObservableOnSubscribe<String> getObservableOnSubscribeError() {
    return new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            for (int i = 0; i <= 3; i++) {
                if (i == 2) {
                    e.onError(new Error("出现错误了"));
                } else {
                    e.onNext(i + "");
                }
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            e.onComplete();
        }
    };
}

private Observer<String> getObserver() {
    return new Observer<String>() {

        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(String s) {
            System.out.println("onNext s================ " + s);
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("onError e============= " + e.toString());
        }

        @Override
        public void onComplete() {
            System.out.println("onComplete================ ");
        }
    };
}