[譯] 大話（Observable 向 Observer 求婚）之我與 Rx Observable [Android RxJava2]（這是什麼鬼）第七話

時間 2019-11-17

標籤大話 observable observer 求婚 android rxjava2 rxjava 這是什麼第七欄目 Hadoop 简体版

原文原文鏈接

原文地址：Continuation (Observable Marriage Proposal to Observer) of Dialogue between Rx Observable and a Developer (Me) [ Android RxJava2 ] ( What the hell is this ) Part7

原文做者：Hafiz Waleed Hussain

譯文出自：掘金翻譯計劃

本文永久連接：github.com/xitu/gold-m…

譯者：dieyidezui

校對者：hanliuxin5

哇哦，又是新的一天，是時候學些新知識了。前端

你們好，但願大家都過得不錯。這是咱們的 RxJava2 Android 系列第七篇文章了，[ part1，part2，part3，part4，part5，part6，part7，part8]。這篇文章裏咱們將繼續和 Rx 聊聊天。java

動機：react

動機和我在第一部分介紹給你們的同樣。android

前言：ios

這篇文章沒什麼前言，由於這是上篇文章的續集呀。可是開始以前，我想咱們仍是要先複習一下上篇文章的內容。上篇文章中，Rx Observerable 告訴了咱們冷熱 Observeable 的含義，隨後我向你們分享了一個相關概念的例子。再而後，我問到了 Subject。但是 Observable 以爲咱們在瞭解 Subject API 以前要先熟悉 Observer API。因此咱們此次從 Observer API 處繼續咱們的對話。git

續集:github

我：是的，那你可否告訴我 Subject 的相關概念和他的不一樣實例，如 Publish、Behaviour 等。express

Observable：呃...我以爲在瞭解這些以前，我得先和你聊聊 Observer 的 API 以及他們是如何工做的，並讓你知道如何使用 Lambda 或者函數式接口來替代一個完整的 Observer 接口。你以爲如何？編程

我：沒問題，我聽你的。後端

Observable：其實咱們已經瞭解了 Observables。並且在以前的例子中，咱們大量使用了多種 Observer。但我以爲在學習新的 API 以前咱們仍是應該先學習她（Observer）。咱們等等她，五六分鐘就到了。

Observer：你好啊，Observable。最近怎麼樣？

Observable：多謝關心，還不錯。 Observer，他(即我)是個人新朋友。他正在學習咱們，因此我但願你把你本身教給他。

Observer:沒問題，你（對我）好啊？

我：你好啊，我挺好的，謝謝。

Observer：在我開始介紹我本身以前，我有一個問題，你知道函數式接口嗎?

我：固然。（註解：若是有人想複習一下這些概念，請參考 part3 )

Observer：很棒。因此你已經知道 Observable 是那個觀察數據流改變的角色了吧。若是有任何的改變，Observable 會通知他的觀察者（們）。所以 Observable 有不少類型，可是你要知道沒有我（Observer），他（Observable）什麼也不是 😛 。

Observable：哈哈哈，徹底正確，親愛的（比心）。

Observer：任何地方只要你能看到 Observable，就百分百能夠看到我。你能夠認爲我就是 Observable 和開發者們（好比我，等等）之間的橋樑。好比你是一個 Rx 的新手，你想要使用一些依賴 Rx 的第三方庫。你只有瞭解我，才能掌握那個庫。我以爲這個說法不爲過。

我：🙂。

Observer：任什麼時候候你想要知道 Observable 關心的那些數據產生了變化或者有什麼事件發生了，你須要使用我來訂閱那個 Observable。而後當 Observable 想要通知你那些變化時，他會經過我來轉告你。 因此你能夠有不少種方式使用我 ，可是首先我會從我最基本的 API 講起。

我：額，我對你的那句「你能夠有不少種方式使用我」有些困惑。

Observer：聽我說完，我相信最後就沒有困惑了。我最基本的 API 有四個方法，以下所示。

public interface Observer<T> {
    void onSubscribe(Disposable var1);

    void onNext(T var1);

    void onError(Throwable var1);

    void onComplete();
}
複製代碼

這裏 T 是 Java 的泛型。我以爲不須要大篇幅討論 Java 的泛型。簡單地說泛型就是若是你在等待 Persion 類型的數據，那麼 T 就是 Persion 類。這裏不須要強制使用全部的四個基本 API，這徹底取決於你的需求。我等會將會給你一些例子，你能夠輕易的決定何時使用這些基本的 API，何時使用更簡化的 API。如今我先一次介紹一個方法。

void onSubscribe(Disposable var1);:
複製代碼

任什麼時候候當你將 Observer 關聯上了 Observable，你將會得到一個 Disposable 對象。他有着很是簡單的 API，以下所示。

public interface Disposable {
    void dispose();

    boolean isDisposed();
}
複製代碼

調用 dispose() 意味着你再也不關注 Observable 的變化。因此任什麼時候候當我想要離開 Observable 時，我就會調用個人 Disposable var1;. var1.dispose() 方法。這也意味着我（Observer）和 Observable 分開了。在那以後任何發生在 Observable 上的事件我都不在關心，我也不會再更新或者傳達這個變化。我稍後會給你展現這個特性很是適合一些場景，尤爲是在 Android 上。第二個是 isDisposed()，這個方法僅在少數狀況有用處，好比我想從 Observable 取得數據，可是我不知道我是否已經被脫離了，因此我能夠用它來檢測是否我被脫離了。反之亦然，在我主動脫離以前，我不肯定我是否已經脫離，我能夠調用這個方法來檢測。若是我調用這個方法後結果是 false，那麼意味着我尚未被脫離，從而我就能夠調用 dispose() 方法。

void onNext(T var1);:
複製代碼

當我訂閱 Observable 後，若是 Observable 想要通知我有變化或者新數據時，就會調用這個方法。我以爲我須要解釋得更不同凡響一些。當 Observable 想要和我結婚時，他就會暴露他的 API subscribe(Observer) 給我，而後經過調用他的 subscribe() API 我接受了他的求婚，可是重要的是我也獲得了 Disposable 對象，這意味着我能夠在任什麼時候候和 Observable 離婚。在咱們結婚期間，Observable 會在他的數據或者事件流有任何變化時通知我。這個時候，Observable 就會調用個人 onNext([any data]) 方法。因此簡單的說當 Observable 的數據有任何變化時就會經過個人 onNext(T data) method 方法通知開發者（我）。

void onError(Throwable var1);:
複製代碼

這個 API 對我來講更加關鍵和重要。任什麼時候候當 Observable 發現了致命的問題，他就會使用個人 onError(Throwable var1) API 通知我。Throwable 會告訴我他的崩潰緣由或者出現了什麼問題。這也意味着任什麼時候候 onError() 被調用後，Disposable.isDispose() 方法永遠會返回 true。因此即便我從不請求離婚，可是當 Observable 面臨一些問題後死去，我可使用 isDispose() 並獲得返回值 true 來發覺這個狀況。

void onComplete();:
複製代碼

這個 API 對我一樣的關鍵和重要。任什麼時候候 Observable 準備好死亡或者與我脫離時，他會使用 onComplete() 來通知我。一樣 Observable 死亡或者與我脫離時，個人 Disposable 會與在 onError() API 中表現得一致。以上的概念但願我都講清了。

我：是的，我只有一個問題。onError 和 onComplete 的區別是什麼，由於在這兩個方法調用後 Observable 都不能再給我發送任何數據的變化。

Observer：你能夠認爲 Observable 因 onError 而死就像人類由於一些疾病而死。好比 Observable 正在觀察服務器的數據可是服務器掛掉了，因此 Observable 是由於某個緣由而死亡，而這個緣由你將會從 onError 的 Throwable 對象中得到。也許是 500 錯誤碼，服務器沒有響應。反之 Observable 因 onComplete() 而死意味着服務器向 Observable 發送了一個完成的消息，在那以後 Observable 再也不適合承載更多的數據，由於他的職責是隻從服務器獲取一次數據。因此在調用 onComplete() 後他將會天然死亡。這就是爲何 Observer，也就是我不能獲取到死亡的緣由，由於他是天然死亡的。有個值得關注的地方，當 onError 被調用後邏輯上 onComplete 是不能被 Observable 調用的，反之亦然。簡單地說 Observable 只能調用這兩個方法之一，onError 或 onComplete。Observable 決不容許同時調用 onError 和 onComplete。這下都清楚了嗎？

我：喔，清楚了。

Observer：如今我將會給你演示如何在實踐中使用我。這個例子中，我將會建立一個每秒都會給我數據的 Observable。我會用不一樣的方式使用這些數據和 Observable 來讓你清楚地明白我全部的 API。

private static Observable<Object> getObservable() {
    return Observable.create(observableEmitter -> {
        Observable.interval(1000, TimeUnit.MILLISECONDS)
                .subscribe(aLong -> observableEmitter.onNext(new Object()));
    });
}
複製代碼

雖然這確實簡單的方法，可是可能仍是會讓你感到困惑。當我與這個 Observable 結婚後，他會每秒給我一個數據。你看到 Observable 是這個方法的返回類型。所以任什麼時候候我訂閱或者與這個 Observable 結婚我將會獲得 Object 類型的數據。下面我將會忽略這些數據並只關注本身方法的調用。

Observer<Object> observer = new Observer<Object>() {
    @Override
    public void onSubscribe(Disposable disposable) {
        ObserverLecture.disposable = disposable;
    }

    @Override
    public void onNext(Object o) {
        System.out.println("onNext called");
    }

    @Override
    public void onError(Throwable throwable) {
        System.out.println("onError called. Die due to reason: "+throwable.getMessage());
    }

    @Override
    public void onComplete() {
        System.out.println("onComplete: Die with natural death");
    }
};
複製代碼

是的，那就是我，彪悍的人生不須要解釋。每當我想要和這個 Observable 結婚或者訂閱他時，我會把我傳入 Observable.subscribe() 方法。

getObservable().subscribe(observer);
複製代碼

這裏你看到了，我和這位 Observable 先生已經結婚了。🙂

完整的代碼：

public class ObserverLecture {

    private static Disposable disposable;

    public static void main(String[] args) {

        Observer<Object> observer = new Observer<Object>() {

            @Override
            public void onSubscribe(Disposable disposable) {
                ObserverLecture.disposable = disposable;
            }
            @Override
            public void onNext(Object o) {
                System.out.println("onNext called");
            }
            @Override
            public void onError(Throwable throwable) {
                System.out.println("onError called. Die due to reason: "+throwable.getMessage());
            }
           @Override
            public void onComplete() {
                System.out.println("onComplete: Die with natural death");
            }
        };
        getObservable().subscribe(observer);
        while (true);
    }
    
    private static Observable<Object> getObservable() {
        return Observable.create(observableEmitter -> {
            Observable.interval(1000, TimeUnit.MILLISECONDS)
                    .subscribe(aLong -> observableEmitter.onNext(new Object()));
        });
    }
}
複製代碼

若是我運行這片代碼，我會持續地獲得下面的輸出，也意味着這個程序永遠不會退出。

輸出： onNext called onNext called onNext called onNext called onNext called

如今我決定向你展現 Disposable，看看咱們討論的是否是對的。我會先給你看看 isDisposable() 方法的使用，他會告訴我我是否是被離婚了。

/**
 * Created by waleed on 14/05/2017.
 */
public class ObserverLecture {

    private static Disposable disposable;

    public static void main(String[] args) throws InterruptedException {

        Observer<Object> observer = new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable disposable) {
                ObserverLecture.disposable = disposable;
            }

            @Override
            public void onNext(Object o) {
                System.out.println("onNext called");
            }

            @Override
            public void onError(Throwable throwable) {
                System.out.println("onError called. Die due to reason: "+throwable.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete: Die with natural death");
            }
        };

        getObservable().subscribe(observer);


        while (true){
            Thread.sleep(1000);
            System.out.println("disposable.isDisposed(): "+disposable.isDisposed());
        }

    }

    private static Observable<Object> getObservable() {
        return Observable.create(observableEmitter -> {
            Observable.interval(1000, TimeUnit.MILLISECONDS)
                    .subscribe(aLong -> observableEmitter.onNext(new Object()));
        });
    }
}
複製代碼

這片代碼和上面的很像，只有 while 循環這一處改變了。在 while 循環中，每一秒我都會打印 Disposable 的值來代表 Observer 是否被離婚了。輸出： disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called … infinite

因此你輕易地看到了 false，這意味着我沒有被離婚由於我歷來沒有調用過 Disposable.dispose() 方法。如今是時候向你展現當我調用 dispose() 後會發生什麼了。

public class ObserverLecture {
    
    private static Disposable disposable;

    public static void main(String[] args) throws InterruptedException {

        Observer<Object> observer = new Observer<Object>() {
            @Override public void onSubscribe(Disposable disposable) {ObserverLecture.disposable = disposable;}
            @Override public void onNext(Object o) {System.out.println("onNext called");}
            @Override public void onError(Throwable throwable) {System.out.println("onError called. Die due to reason: " + throwable.getMessage());}
            @Override public void onComplete() {System.out.println("onComplete: Die with natural death");}
        };

        getObservable().subscribe(observer);
        
        int count = 0;
        while (true) {
            Thread.sleep(1000);
            System.out.println("disposable.isDisposed(): " + disposable.isDisposed());

            count++;
            if (count == 3)
                disposable.dispose();
        }

    }

    private static Observable<Object> getObservable() {
        return Observable.create(observableEmitter -> {
            Observable.interval(1000, TimeUnit.MILLISECONDS)
                    .subscribe(aLong -> {
                        observableEmitter.onNext(new Object());
                    });
        });
    }
}
複製代碼

這裏的代碼和上面的也只有在 while 循環處一個不一樣。此次我添加了一個 count 變量，因此在我從 Observable 得到三次數據後我就會調用 dispose，從而讓我和 Observable 離婚了。輸出： onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false disposable.isDisposed(): true disposable.isDisposed(): true disposable.isDisposed(): true …

如今你從輸出中能看到，三次後我獲得了 true，這意味着我離婚了。問題 Observable 身上將會發生什麼，他會死去嗎？爲了解決這個問題，我引入一個概念叫作冷、熱 Observable。若是他是熱 Observable 那麼他不會死去。但若是他是冷的，他將會中止發送數據。

如今我以爲沒有必要去討論 onNext() 了，由於咱們已經在咱們的例子中看到了這個方法會在 Observable 數據有任何改變的時候被調用。因此是時候討論一下 onError() 和 onComplete() 了，同時包括疾病死亡和天然死亡。

public class ObserverLecture {

    private static Disposable disposable;

    public static void main(String[] args) throws InterruptedException {

        Observer<Object> observer = new Observer<Object>() {
            @Override public void onSubscribe(Disposable disposable) {ObserverLecture.disposable = disposable;}
            @Override public void onNext(Object o) {System.out.println("onNext called");
                                                    System.out.println("disposable.isDisposed(): " + disposable.isDisposed());}
            @Override public void onError(Throwable throwable) {System.out.println("onError called. Die due to reason: " + throwable.getMessage());}
            @Override public void onComplete() {System.out.println("onComplete: Die with natural death");}
        };
        getObservable().subscribe(observer);

        while (true) {
            Thread.sleep(1000);
            System.out.println("disposable.isDisposed(): " + disposable.isDisposed());
        }
    }

    private static Observable<Object> getObservable() {
        return Observable.create(observableEmitter -> {
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onError(new RuntimeException("Die due to cancer"));
        });
    }
}
複製代碼

這裏除了建立 Observable 的方法，我用的代碼和上面幾乎同樣。這個 Observable 會發送四次數據，而後會由於一些緣由死去。這裏我顯示地創造了這個緣由，這樣咱們纔好理解 onError() 的概念。輸出： onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onError called. Die due to reason: Die due to cancer disposable.isDisposed(): true disposable.isDisposed(): true …

這裏你也能輕鬆地看到，在咱們的 Observable 死去時，他調用了個人 onError 方法。在他死後，個人 isDisposed() 總會返回 true。這說明我離婚了或成爲了寡婦。

是時候看一下 onComplete() 了。

public class ObserverLecture {

    private static Disposable disposable;

    public static void main(String[] args) throws InterruptedException {

        Observer<Object> observer = new Observer<Object>() {
            @Override public void onSubscribe(Disposable disposable) {ObserverLecture.disposable = disposable;}
            @Override public void onNext(Object o) {System.out.println("onNext called"); System.out.println("disposable.isDisposed(): " + disposable.isDisposed());}
            @Override public void onError(Throwable throwable) {System.out.println("onError called. Die due to reason: " + throwable.getMessage());}
            @Override public void onComplete() {System.out.println("onComplete: Die with natural death");}
        };

        getObservable().subscribe(observer);

        while (true) {
            Thread.sleep(1000);
            System.out.println("disposable.isDisposed(): " + disposable.isDisposed());

        }

    }

    private static Observable<Object> getObservable() {
        return Observable.create(observableEmitter -> {
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onNext(new Object());
            observableEmitter.onComplete();
        });
    }
}
複製代碼

你也看到了，我就改了一處地方。Observable 主動調用了 onComplete 方法。輸出： onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onNext called disposable.isDisposed(): false onComplete: Die with natural death disposable.isDisposed(): true disposable.isDisposed(): true disposable.isDisposed(): true

咱們很容易就看到，我在調用 Disposable.isDisposed() 時一直是 false，說明我尚未離婚，我還能夠從 Observable 得到數據，可是當 onComplete() 調用後 isDispose() 永遠返回 true。這意味着由於 Observable 的天然死亡，我離婚了或者是變成了寡婦。

我：喔！謝謝你，Observer。你解釋地很棒，幫我解答了不少關於你的疑惑。可是我有些好奇爲何有時候人們使用只有一個方法的 Consumer 來替代 Observer。這是什麼方法？

Observer：首先感謝你的誇獎。我能夠向你解釋更多的 API，可是首先我以爲你應該在 Android 中使用上面的概念並給我一個示例，這樣對你們都有幫助。

我：我贊成你的想法，可是我以爲當務之急先學習關於你的一切，而後我會給你一個 Android 中使用上述全部 API 的真實的例子。

Observer：好吧，如你所願。有時候需求並不複雜，儘管你可使用 Observer 的四個方法可是我以爲使用這四個方法不是必須的，你徹底能夠用更少的代碼來完成需求。所以我把我本身切分紅了幾個函數式接口，你也能夠認爲這是對 Observer 的語法糖。例如：

public class ObserverLecture {

    public static void main(String[] args) {

        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable disposable) {
                    
                    }

                    @Override
                    public void onNext(String string) {
                        System.out.println("onNext: "+string);

                    }

                    @Override
                    public void onError(Throwable throwable) {
                        System.out.println("onError");
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("onComplete");
                    }
                });
    }
}
複製代碼

輸出： onNext: A onNext: B onNext: C onNext: D onComplete

這裏你能看到我只關注數據，可是我不得不實現 onSubscribe、onError 和 onComplete 方法。看下個例子是如何使用更少的代碼來達到相同的目的。

public class ObserverLecture {

    public static void main(String[] args) {

        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(s -> System.out.println(s));

    }
}
複製代碼

上述這兩個例子在功能上是如出一轍的，可是此次你看的例子只用了兩行代碼，而上面的那個代碼則很是的長。因此我想和你分享我全部的函數式接口以及你如何在你的應用中使用它們。

public interface Consumer<T> {
    void accept(@NonNull T var1) throws Exception;
}
複製代碼

public interface Action {
    void run() throws Exception;
}
複製代碼

我有兩個函數式接口，一個最好使的 Consumer，還有一個是 Action。咱們先聊一下 Consumer 接口。當我只關注數據且並不在意任何其餘狀態的變化時，好比我不想使用 Disposable 瞭解是否被分離，我也不想知道 Observable 是否死亡以及是不是天然死亡仍是疾病死亡。在這種狀況下，我就可使用 Consumer API。所以我很感謝 Observable 提供這個選項讓我使用個人函數式接口來訂閱他。

Observable：🙂

Observer：是時候讓你看看咱們使用的示例了。

public static void main(String[] args) {

    List<String> strings = Arrays.asList("A", "B", "C", "D");
    Observable.fromIterable(strings)
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println(s);
                }
            });
}
複製代碼

這裏我僅僅訂閱了 Observable 的 onNext() 回調，你很容易就能看出來我生成了一個匿名內部類給 Observable 來訂閱。下面更神奇的來了，我有和大家說過我有函數式接口，這意味着我能生成一個 Lambda 表達式給 Observable 來訂閱而再也不須要匿名內部類或者接口對象。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(s -> System.out.println(s));
    }
}
複製代碼

喔，你看到上面的例子了，就一行代碼。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(System.out::println);
    }
}
複製代碼

喔，用了更少的代碼量。這裏我使用了方法引用，可是上面的兩塊代碼功能上是徹底一致的。下面的例子還有個技巧。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer);
    }

    private static Consumer<String > consumer = System.out::print;
    //private static Consumer<String > consumer2 = s->{};
}
複製代碼

這裏我單獨定義了個人 Consumer 函數式接口，並使用這個對象來訂閱。下面是若是我也想知道錯誤的信息，我將如何被相同的函數式接口通知到。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        System.out.println("Die due to "+throwable.getMessage());
                    }
                });
    }

    private static Consumer<String > consumer = System.out::print;
}
複製代碼

這裏你能夠看到 Observable 的 subscribe 方法的第二個參數是用來通知 onError 的。所以我也生成了一個相同的 Consumer 函數式接口，這個接口的泛型 T 是 Throwable 類。這麼用真的是超級簡答。下面是我如何使用 Lambda 表達式得到相同的內容。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer,
                        throwable -> System.out.println("Die due to "+throwable.getMessage()));
    }

    private static Consumer<String > consumer = System.out::print;
}
複製代碼

下面是我如何使用方法引用實現一樣的功能。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, System.out::print);
    }

    private static Consumer<String> consumer = System.out::print;
}
複製代碼

喔，只有一件事要注意的是，這裏的方法引用僅僅是調用了 Throwable.toString()，並不能展示咱們自定義的消息。就像上面例子的那樣**(System.out.println(「Die due to 「+throwable.getMessage())**。如今是時候向你展現使用定義我本身的 Error Consumer API 並生成一個那樣的對象來訂閱。

public class ObserverLecture {
    
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error);
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
}
複製代碼

我知道你如今必定很好奇如何知道 Observable 的 onComplete() 是否被調用。對於那種狀況，我可使用 Action 接口。我須要生成一個 Action 接口來做爲 Observable 的 subscribe 的第三個參數，從而我能從 Action 接口的回調了解到 Observable 是否完成。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, new Action() {
                    @Override
                    public void run() throws Exception {
                        System.out.println("OnComplete");
                    }
                });
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
}
複製代碼

這兒你能看到個人 Action 匿名內部類做爲訂閱的第三個接口。下面我要給你看下咱們如何使用 Lambda 表達式和使用方法引用以及使用第一個單獨定義的對象替代它。

Lambda 表達式：

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, 
                        () -> System.out.println("OnComplete"));
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
}
複製代碼

方法引用：

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, System.out::println);
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
}
複製代碼

這兒我想提醒一件事，方法引用用在這裏只是幫助你理解概念，實際中沒什麼做用，由於只是向控制檯輸出了一個空行。

一個定義好的對象：

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, complete);
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
    private static Action complete = ()-> System.out.println("onComplete");
}
複製代碼

因此你也看到了，第三個參數實際上是 Action 而不是Consumer。請牢記。

最後一個是 Disposable。當我想分離時，我如何得到一個 Disposable 呢，這時咱們能夠用泛型 T 爲 Disposable 的 Consumer 做爲訂閱的第四個參數。

public class ObserverLecture {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, complete, new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        
                    }
                });
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
    private static Action complete = ()-> System.out.println("onComplete");
}
複製代碼

到這兒我就能得到 Disposable 了。看到這想必你也明白了，我既能夠實現一個 Observer 也能夠用函數式接口作到一樣的事。也就是說 Observer 訂閱等於四個函數式接口訂閱的組合（Consumer, Consumer, Action, Consumer）。好了，下面再給你看下咱們如何使用 Lambda 表達式替代 Consumer。

public class ObserverLecture {

    private static Disposable d;

    public static void main(String[] args) {

        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, complete, disposable -> d = disposable);
    }

    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
    private static Action complete = ()-> System.out.println("onComplete");
}
複製代碼

做爲一個獨立定義的對象：

public class ObserverLecture {

    private static Disposable d;

    public static void main(String[] args) {

        List<String> strings = Arrays.asList("A", "B", "C", "D");
        Observable.fromIterable(strings)
                .subscribe(consumer, error, complete, disposable);
        
    }
    
    private static Consumer<String> consumer = System.out::print;
    private static Consumer<Throwable> error = System.out::print;
    private static Action complete = ()-> System.out.println("onComplete");
    private static Consumer<Disposable> disposable = disposable -> d = disposable;
}
複製代碼

但願我都把一切都講清楚了。最後我還想說下，用 Observer 接口或者使用函數式接口徹底取決於開發者們自身的選擇。還有問題嗎？

Observable：等一下。我還想再次感謝一下 Observer，耽誤了她很多時間。我以爲你應該藉此給出一個更加合適的、實際中用到的、包含上面所有概念的例子，這應該幫助到讀者。

我：首先我也要先謝謝 Observer，你真棒！那 Observable，我等會給出一個 Android 中的例子吧，而後我就想學習 Observable 中的 Subject 了。

Observable：哈哈，好的。我就在這兒哪都不去，可是在那以前咱們要先和 Observer 說再見了。

我：是的，謝謝 Observer 用你寶貴的時間給咱們分享。其實我在平常編程任務中已經大量使用你了，可是直到如今我才知道爲何我須要使用你以及你是如何工做的。再次感謝！

結語：朋友們，你們好。但願上面的知識點都講清楚了，不過要在平常實踐中多多使用上面的知識點哦。如今我想應該和你們說再見了，週末愉快。 🙂

掘金翻譯計劃是一個翻譯優質互聯網技術文章的社區，文章來源爲掘金上的英文分享文章。內容覆蓋 Android、iOS、前端、後端、區塊鏈、產品、設計、人工智能等領域，想要查看更多優質譯文請持續關注掘金翻譯計劃、官方微博、知乎專欄。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。