2. 程式人生 > >RxJava 學習筆記（九） --- Error Handling 錯誤處理操作

RxJava 學習筆記（九） --- Error Handling 錯誤處理操作

阿新 • • 發佈：2018-12-30

1. onErrorReturn —> 指示Observable在遇到錯誤時發射一個特定的資料

onErrorReturn方法返回一個映象原有Observable行為的新Observable，後者會忽略前者的onError呼叫，不會將錯誤傳遞給觀察者，作為替代，它會發發射一個特殊的項並呼叫觀察者的onCompleted方法。

            enter image description here

示例程式碼：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
 

            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //迴圈輸出數字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw
 
 new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onErrorReturn(new
 
 Func1<Throwable, Integer>() {
            @Override
            public Integer call(Throwable throwable) {
                return 1004;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

輸出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:1004 
Sequence complete.

2. onErrorResumeNext —> 指示Observable在遇到錯誤時發射一個數據序列

            enter image description here

onErrorResumeNext方法返回一個映象原有Observable行為的新Observable，後者會忽略前者的onError呼叫，不會將錯誤傳遞給觀察者，作為替代，它會開始映象另一個，備用的Observable。

示例程式碼：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //迴圈輸出數字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onErrorResumeNext(new Func1<Throwable, Observable<? extends Integer>>() {
            @Override
            public Observable<? extends Integer> call(Throwable throwable) {
                return Observable.just(100,101, 102);
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

輸出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.

3. onExceptionResumeNext —> 指示Observable遇到錯誤時繼續發射資料

和onErrorResumeNext類似，onExceptionResumeNext方法返回一個映象原有Observable行為的新Observable，也使用一個備用的Observable，不同的是，如果onError收到的Throwable不是一個Exception，它會將錯誤傳遞給觀察者的onError方法，不會使用備用的Observable。

            enter image description here

示例程式碼：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //迴圈輸出數字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onExceptionResumeNext(Observable.just(100, 101, 102)).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

輸出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.

4. retry —> 指示Observable遇到錯誤時重試

如果原始Observable遇到錯誤，重新訂閱它期望它能正常終止

            enter image description here

Retry操作符不會將原始Observable的onError通知傳遞給觀察者，它會訂閱這個Observable，再給它一次機會無錯誤地完成它的資料序列。Retry總是傳遞onNext通知給觀察者，由於重新訂閱，可能會造成資料項重複，如上圖所示。

RxJava中的實現為retry和retryWhen。

無論收到多少次onError通知，無引數版本的retry都會繼續訂閱併發射原始Observable。

接受單個count引數的retry會最多重新訂閱指定的次數，如果次數超了，它不會嘗試再次訂閱，它會把最新的一個onError通知傳遞給它的觀察者。

還有一個版本的retry接受一個謂詞函式作為引數，這個函式的兩個引數是：重試次數和導致發射onError通知的Throwable。這個函式返回一個布林值，如果返回true，retry應該再次訂閱和映象原始的Observable，如果返回false，retry會將最新的一個onError通知傳遞給它的觀察者。

retry操作符預設在trampoline排程器上執行。

示例程式碼：retry(long)

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //迴圈輸出數字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.retry(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

輸出：

Next:0 
Next:1 
Next:2 
Next:3

Next:0 
Next:1 
Next:2 
Next:3

Next:0 
Next:1 
Next:2 
Next:3 
Error: this is number 4 error！

示例程式碼：retry(Func2)

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //迴圈輸出數字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.retry(new Func2<Integer, Throwable, Boolean>() {
            @Override
            public Boolean call(Integer integer, Throwable throwable) {
                return integer < 3;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next--:" + value);
            }
        });

輸出：

Next--:0
Next--:1
Next--:2
Next--:3
Next--:0
Next--:1
Next--:2
Next--:3
Next--:0
Next--:1
Next--:2
Next--:3
Error: this is number 4 error！

5. retryWhen —> 指示Observable遇到錯誤時，將錯誤傳遞給另一個Observable來決定是否要重新給訂閱這個Observable

retryWhen和retry類似，區別是，retryWhen將onError中的Throwable傳遞給一個函式，這個函式產生另一個Observable，retryWhen觀察它的結果再決定是不是要重新訂閱原始的Observable。如果這個Observable發射了一項資料，它就重新訂閱，如果這個Observable發射的是onError通知，它就將這個通知傳遞給觀察者然後終止。

retryWhen預設在trampoline排程器上執行，你可以通過引數指定其它的排程器。

            enter image description here

示例程式碼：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                System.out.println("subscribing");
                subscriber.onError(new RuntimeException("always fails"));
            }
        });

        observable.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Throwable> observable) {
                return observable.zipWith(Observable.range(1, 3), new Func2<Throwable, Integer, Integer>() {
                    @Override
                    public Integer call(Throwable throwable, Integer integer) {
                        return integer;
                    }
                }).flatMap(new Func1<Integer, Observable<?>>() {
                    @Override
                    public Observable<?> call(Integer integer) {
                        System.out.println("delay retry by " + integer + " second(s)");
                        //每一秒中執行一次
                        return Observable.timer(integer, TimeUnit.SECONDS);
                    }
                });
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

輸出:

subscribing 
delay retry by 1 second(s) 
subscribing 
delay retry by 2 second(s) 
subscribing 
delay retry by 3 second(s) 
subscribing 
Sequence complete.

相關推薦

RxJava 學習筆記（九） --- Error Handling 錯誤處理操作

1. onErrorReturn —> 指示Observable在遇到錯誤時發射一個特定的資料 onErrorReturn方法返回一個映象原有Observable行為的新Obse

Go學習筆記（九）介面，錯誤處理

介面 提供了另外一種資料型別即介面，它把所有的具有共性的方法定義在一起，任何其他型別只要實現了這些方法就是實現了這個介面。 package main import ( "fmt" ) type Phone interface { ca

TypeScript學習筆記（九）：裝飾器（Decorators）

標註 時裝 als cal () 操作 enume 筆記 文檔 裝飾器簡介 裝飾器（Decorators）為我們在類的聲明及成員上通過元編程語法添加標註提供了一種方式。 需要註意的是：裝飾器是一項實驗性特性，在未來的版本中可能會發生改變。 若要啟用實驗性的裝飾器特性

如鵬網學習筆記（九）JavaScript

計算機編程 lean 有效 拼接字符串 {} efault 含義 函數重載 cas JavaScript筆記 一、JavaScript簡介 　　1，JavaScript是一種計算機編程語言，可以像等其他編程語言那樣定義變量，執行循環等。 　　2，JavaScript代碼主

Python學習筆記（九）

port 驗證方式 模塊 install name 第三方模塊 rom pip private 一、Python模塊的引入 　　import sys #可以通過模塊名以及import關鍵字導入模塊 二、if __name__ == "__main__" 　　當Python在

深度學習筆記（九）感受野計算

lds 時有 輸入 計算 ret name %d have imsi 1 感受野的概念 　　在卷積神經網絡中，感受野的定義是 卷積神經網絡每一層輸出的特征圖（feature map）上的像素點在原始圖像上映射的區域大小。一般感受野大小是目標大小的兩倍左右最合適！ 　　 　　

java學習筆記（九）：Java 流(Stream)、文件(File)和IO

用戶輸入 public 文件內容 輸出流 out 單個 java 我們 ready Java 的控制臺輸入由 System.in 完成。 為了獲得一個綁定到控制臺的字符流，你可以把 System.in 包裝在一個 BufferedReader 對象中來創建一個字符流。需要i

學習筆記（九）——數據庫存儲結構：頁、聚集索引、非聚集索引

分享 style end 宋體 blog lec storage rop cas 1、頁 SQL Server用8KB 的頁來存儲數據，並且在SQL Server裏磁盤 I/O 操作在頁級執行。也就是說，SQL Server 讀取或寫入所有數據頁。頁有不同的類型，像

Elasticsearch學習筆記（九）partial update

cse adding 操作 nbsp 進行 樂觀 gin clas 比較 一、什麽是partial update？ PUT /index/type/id，創建文檔&替換文檔，就是一樣的語法 一般對應到應用程序中，每次的執行流程基本是這樣的： （1）應

python學習筆記（九）之語句1

如果 red 開始 就是 整除 for 循環 個數 hello 基本 python學習筆記（九）之語句1printpython2中，print是一個語句，python3中它是一個函數。實例1: >> print "hello,world!"

day5-Python學習筆記（九）json數據類型

class json mps pen log imp color python 文件 import json#json串就是字符串。d = { ‘car‘:{‘color‘:‘red‘,‘price‘:100,‘count‘:50}, ‘挨糞叉‘:{‘color‘:

《Qt5 開發與實例（第三版）》學習筆記（九）

nal inf lin exc ken right item vbo ott 1 // 3.4 基本布局(QLayout) 2 //dialog.h 3 #ifndef DIALOG_H 4 #define DIALOG_H 5 6 #incl

Linux學習筆記（九）find、文件名後綴

行為 指定文件類型 type install 需要 所有 如果 查找文件 size 一、linux中查找文件有很多種法，例如之前用過的which、whereis，此外還有locate 如果沒有安裝locate ，則需要運行 yum install -y mlocate

kettle學習筆記（九）——子轉換、集群與變量

bec param TP 一個 字段 暴露 空格 參數用法 用法 一、概述 　　kettle中3個重要的步驟： 　　　　子轉換/映射 　　　　　　在轉換裏調用一個子轉換，便於封裝和重用。 　　　　集群 　　　　　　集群模式 　　　　變量和參數 　　　　　　變量和參數的用法

WPF 學習筆記（九）

toolbar 添加 mas eight click top dock horizon ima 一、菜單的創建 <Window x:Class="WpfApplication6.MainWindow" xmlns="http://schemas

Cocos2d-x學習筆記（九）例項——場景自動切換

【關於場景自動切換】 如何實現場景的自動切換？我嘗試過很多種方法，比如在AppDelegate.cpp檔案中的applicationDidFinishLaunching()函式中， 想在pDirector->runWithScene(pLandlords);中直接使用replace

javaweb學習筆記（九）：JavaScript（2）

目錄 1.BOM 1.1window物件 1.2history物件 1.3location物件 2. DOM 2.1dom節點及獲取 2.2Event 1.BOM 1.1window物件 一般來說，Window 物件的方法都是對瀏覽器視窗或框架進行某種

java學習筆記（九）-- java新特性 （ 可變引數 & 泛型 & 靜態匯入 & 型別擦除 ）

JDK1.5新特性 方法的可變引數             設計一個方法，可以接收任意個數的整數，並返回他們的相加結果       

python基礎教程（第三版)學習筆記（九）

第九章 魔法方法、特性和迭代器 9.1 如果你使用的不是python3 在Python 2.2中，Python物件的工作方式有了很大的變化。這種變化帶來了多個方面的影響。這些影響對Python程式設計新手來說大都不重要，但有一點需要注意：即便你使用的是較新的Python 2版本，有些功能（如特性

學習筆記（九）：使用支援向量機識別XSS

1.特徵化：提取特徵，對特徵進行向量化，標準化，均方差縮放，去均值操作 def get_len(url): return len(url) def get_url_count(url): if re.search('(http://)|(http://)',url,re.IGNO