[譯] 理解 RxJava 中的 Single 和 Completable

CyrusRowe 8年前發布 | 19K 次閱讀 RxJava 安卓開發

在大多數 RxJava 示例代碼和教程中出現最為頻繁的一個類 —— Observable ，它是產生響應式編程魔力的關鍵。它的用法很簡單，只需要跟蹤 3 個事件 —— onNext ， onError 和 onCompleted 就可以應用上百個操作符來實現自己的表達式。那么為什么你還需要了解其他東西？

但是你仔細思考下，你真的需要每次都知道這 3 個事件嗎？實際上，在大多數情況下并不需要。 ReactiveX 文檔中講述的基本都是關于連續的事件流，因此我們經常忘記通常我們關心的只是監聽 單一事件 或者只監聽 completed or failed 事件 。

在這種情況下我們應該考慮用 RxJava 的兩個絕妙的設計 —— Single<T> 和 Completable ，在分析兩者之前，讓我們先看看他們應用場景的示例。

本文中所有代碼都是基于 RxJava 2.x ，不是 1.x 版本。如果你還沒升級 RxJava 到最新的 2.x 版本，強烈建議你馬上升級。

Single

在 Android 中使用 RxJava 最常見的場景就是網絡請求，你可能使用 Retrofit 作為項目的 Http client。假設你有一個 GET HTTP 請求返回一些數據，同時使用 RxJavaAdapter 你大概會這么寫：

public interface APIClient {

    @GET("my/api/path")
    Observable<MyData> getMyData();
}

上面的代碼沒什么問題，當調用它時：

apiClient.getMyData()
    .subscribe(new Consumer<MyData myData>() {
        @Override
        public void accept(MyData myData) throws Exception {
            // handle data fetched successfully
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error event
        }
    }, new Action() {
        @Override
        public void run() throws Exception {
            // handle on complete event
        }
    });

仔細思考下，其實這個網絡請求并不是一個連續事件流，你只會發起一次 Get 請求返回數據并且只收到 一個事件 。我們都知道這種情況下 onComplete 會緊跟著 onNext 被調用，那為什么不把它們合二為一呢？

在上面這種情況下為了更清楚的體現請求的意圖，應該用 Single<MyData> 替換 Observable。從官方文檔中對 Single 的說明可以發現為什么它是最恰當的選擇： A Single is something like an Observable, but instead of emitting a series of values — anywhere from none at all to an infinite number — it always either emits one value or an error notification 。所以修改后 API client 是這樣的：

public interface APIClient {

    @GET("my/api/path")
    Single<MyData> getMyData();
}

同時請求的調用也可以簡化：

apiClient.getMyData()
    .subscribe(new Consumer<MyData>() {
        @Override
        public void accept(MyData myData) throws Exception {
            // handle data fetched successfully and API call completed
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error event
        }
    });

最值得高興的是 Single 基本上實現了 Observable 所有的操作符 —— map 、 flatMap 、 filter 、 zip 等，如果你發現需要用到一個 Observable 的操作符而 Single 并不支持，你可以用 toObservable 操作符把 Single<T> 轉換為 Observable<T> 。

apiClient.getMyData()
    .toObservable()
    // This is an Observable<MyData> now

如果你有 Observable 表現地像 Single 一樣，也可以通過 singleOrError 操作符轉換為 Single。

Completable

繼續討論 Retrofit 的例子，再看看另外一種常用場景 —— 通過 PUT 請求更新數據。我們修改了 MyData 類型對象的一些屬性，把它發送到服務器更新服務器數據庫。大部分服務器 API 設計都是成功后返回更新后的對象，所以你的 API client 的實現是：

public interface APIClient {

    @PUT("my/api/updatepath")
    Observable<MyData> updateMyData(@Body MyData data);
}

同樣的，跟之前的例子類似，應該這樣調用：

apiClient.updateMyData(myUpdatedData)
    .subscribe(new Consumer<MyData myData>() {
        @Override
        public void accept(MyData myData) throws Exception {
            // handle data fetched successfully and API call completed
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error event
        }
    }, new Action() {
        @Override
        public void run() throws Exception {
            // handle completion - what we actually care about
        }
    });

你可能會說這里我們可以同樣用 Single 來簡化代碼，是的沒錯。在這種情況下我們仍然需要 MyData 結果，確定？服務器返回給我們更新后的數據是良好的設計，當時實際上僅僅是返回給我們之前發送給它的對象。我們真正需要的 只是更新成功了 ，這意味著，我只關心 onComplete 事件。

這也是引入 Completable 的原因，官方文檔對它的描述是： Represents a computation without any value but only indication for completion or exception 。使用 Completable 時我們忽略 onNext 事件， 只處理 onComplete 和 onError 事件 ，API client 改寫為：

public interface APIClient {

    @PUT("my/api/updatepath")
    Completable updateMyData(@Body MyData data);
}

調用為：

apiClient.updateMyData(myUpdatedData)
    .subscribe(new Action() {
        @Override
        public void run() throws Exception {
            // handle completion
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error
        }
    });

Completable 本質上來說和 Observable 與 Single 不一樣，因為它不發射數據。因此 Completable 的操作符也有所區別，最常用的是 andThen 。在這個操作符中你可以傳任何 Observable 、 Single 、 Flowable 、 Maybe 或者其他 Completable ，它們會在原來的 Completable 結束后執行。例如。你想執行一些其他操作（Single）：

apiClient.updateMyData(myUpdatedData)
    .andThen(performOtherOperation()) // a Single<OtherResult>
    .subscribe(new Consumer<OtherResult>() {
        @Override
        public void accept(OtherResult result) throws Exception {
            // handle otherResult
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error
        }
    });

跟 Single 不同的是 RxJava 不允許直接把 Observable 轉換為 Completable，因為沒辦法知道一個 Observable 什么時候 complete。但是你可以把 Single 轉換為 Completable，因為 Single 保證 onComplete 會被調用，這個操作符是 toCompletable 。

希望通過這篇簡短的對 Single 和 Completable 的介紹能讓你理解這兩個概念從而寫出更簡潔的代碼。

來自：http://johnnyshieh.github.io/android/2017/03/15/rxjava-single-completable/

本文由用戶 CyrusRowe 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1489644781346.html

RxJava 安卓開發

[譯] 理解 RxJava 中的 Single 和 Completable

Single

Completable

相關經驗

相關資訊

相關文檔

目錄