android

rxjava : 錯誤處理運算子 (1):retry 、 retryUntil 、 retryWhen


當.repeat()接收到.onCompleted()事件後觸發重訂閱。

當.retry()接收到.onError()事件後觸發重訂閱。

參考:

[Android開發] RxJava2之路七 – 錯誤處理運算子例子Demo

RX運算子之錯誤處理(catch[onErrorReturn、onErrorResumeNext、onExceptionResumeNext]、retry、retryWhen)

retry運算子

重試的意思,攔截到錯誤,然後讓 被觀察者重新發射資料。Throwable和Exception都額可以攔截

它有五種引數方法:

  • retry(): 讓被觀察者重新發射資料,要是一直錯誤就一直髮送了

  • retry(BiPredicate): interger是第幾次重新發送,Throwable是錯誤的內容

  • retry(long time): 最多讓被觀察者重新發射資料多少次

  • retry(long time,Predicate predicate): 最多讓被觀察者重新發射資料多少次,在predicate裡面進行判斷攔截 返回是否繼續

  • retry(Predicate predicate): 在predicate裡面進行判斷攔截 返回是否繼續

retry 測試:


//public final Observable<T> retry()
public void retryTest() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retry()    //無限重試
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//.........





//public final Observable<T> retry(long times)
public void retryTest1() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retry(3)    //最多讓被觀察者重新發射資料3次
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//結果錯誤============= .lang.Exception: 出現錯誤了




// public final Observable<T> retry(Predicate<? super Throwable> predicate)
public void retryTest2() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retry(new Predicate<Throwable>() {
                @Override
                public boolean test(@NonNull Throwable throwable) throws Exception {
                    System.out.println("retry錯誤================= " + throwable.toString());
                    //返回假就是不讓重新發射資料了,呼叫觀察者的onError就終止了。
                    //返回真就是讓被觀察者重新發射請求
                    return true;
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤================= .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤================= .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤================= .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤================= .lang.Exception: 出現錯誤了
//...............




//public final Observable<T> retry(long times, Predicate<? super Throwable> predicate)
public void retryTest3() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retry(3, new Predicate<Throwable>() {
                @Override
                public boolean test(@NonNull Throwable throwable) throws Exception {
                    System.out.println("retry錯誤============== " + throwable.toString());
                    //最多讓被觀察者重新發射資料3次,但是這裡返回值可以進行處理
                    //返回假就是不讓重新發射資料了,呼叫觀察者的onError就終止了。
                    //返回真就是讓被觀察者重新發射請求
                    return true;
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤============== .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤============== .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤============== .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//結果錯誤============= .lang.Exception: 出現錯誤了



// public final Observable<T> retry(BiPredicate<? super Integer, ? super Throwable> predicate)
public void retryTest4() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retry(new BiPredicate<Integer, Throwable>() {
                @Override
                public boolean test(@NonNull Integer integer, @NonNull Throwable throwable) {
                    System.out.println("retry錯誤========" + integer + " " 
                    						+ throwable.toString());
                    //返回假就是不讓重新發射資料了,呼叫觀察者的onError就終止了。
                    //返回真就是讓被觀察者重新發射請求
                    return true;
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤========1 .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤========2 .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤========3 .lang.Exception: 出現錯誤了
//收到訊息================ 0
//收到訊息================ 1
//retry錯誤========4 .lang.Exception: 出現錯誤了
//...................



private ObservableOnSubscribe<String> getObservableOnSubscribe() {
    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 Observer<String> getObserver() {
    return new Observer<String>() {

        @Override
        public void onSubscribe(Disposable d) {

        }

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

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

        @Override
        public void onComplete() {

        }
    };
}

retryUntil 測試:


public void retryUntil1() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retryUntil(new BooleanSupplier() {
                @Override
                public boolean getAsBoolean() throws Exception {
                    return false;//false 繼續訂閱
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//..............



public void retryUntil2() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retryUntil(new BooleanSupplier() {
                @Override
                public boolean getAsBoolean() throws Exception {
                    return true;//true : 不在訂閱
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//結果錯誤============= java.lang.Exception: 出現錯誤了

retryWhen 測試:


//retryWhen和retry類似,
// 區別是:
// retryWhen將onError中的Throwable傳遞給一個函式,這個函式產生另一個Observable,
// retryWhen觀察它的結果再決定是不是要重新訂閱原始的Observable。
//如果這個Observable發射了一項資料,它就重新訂閱,
// 如果這個Observable發射的是onError通知,它就將這個通知傳遞給觀察者然後終止。
public void retryWhen1() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                @Override
                public ObservableSource<?> apply(Observable<Throwable> throwableObservable){
                    //這裡可以傳送新的被觀察者 Observable
                    return throwableObservable
                    			.flatMap(new Function<Throwable, ObservableSource<?>>() {
                        @Override
                        public ObservableSource<?> apply(@NonNull Throwable throwable){
                            //如果發射的onError就終止
                            return Observable.error(new Throwable("retryWhen終止啦"));
                        }
                    });
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//結果錯誤============= java.lang.Throwable: retryWhen終止啦



public void retryWhen2() {
    Observable.create(getObservableOnSubscribe())
            .subscribeOn(Schedulers.newThread())
            .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                @Override
                public ObservableSource<?> apply(Observable<Throwable> throwableObservable){
                    //這裡可以傳送新的被觀察者 Observable
                    return throwableObservable 
                    		.flatMap(new Function<Throwable, ObservableSource<?>>() {
                        @Override
                        public ObservableSource<?> apply(@NonNull Throwable throwable){
                            //如果發射的onError就終止,否則重新訂閱
                            return Observable.just("再試試?");
                        }
                    });
                }
            })
            .subscribe(getObserver());
}
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//收到訊息================ 0
//收到訊息================ 1
//...........


本文章已修改原文用詞符合繁體字使用者習慣使其容易閱讀

版權宣告:此處為CSDN博主「Mars-xq」的原創文章,依據CC 4.0 BY-SA版權協議,轉載請附上原文出處連結及本宣告。

原文連結:https://blog.csdn.net/sinat_31057219/article/details/101302061