[译] 大话（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、前端、后端、区块链、产品、设计、人工智能等领域，想要查看更多优质译文请持续关注掘金翻译计划、官方微博、知乎专栏。