RxJava学习 - 2. The Observer interface

onNext()、onComplete()和onError()方法在Observer里定义，Observer是一个abstract interface，用来传递这些事件。
后面再将onSubscribe()方法，先看这三个方法：

package io.reactivex;

import io.reactivex.disposables.Disposable;

public interface Observer<T> {
    void onSubscribe(Disposable d);
    void onNext(T value);
    void onError(Throwable e);
    void onComplete();
}

Observers和源Observables是相关的。在一个context里，source Observable是你的Observable chain的起点。我们前面的例子，Observable.create()方法或者Observable.just()方法返回的Observable是源Observable。对于filter()，从map()返回的Observable是源。它不知道源头在哪里，它只知道从哪儿接收的emissions。
通过一个运算返回的Observable的内部有一个Observer，它接收、转换、中继emissions给下游的Observer。它不知道下一个Observer是另一个运算，还是最终的Observer。当我们谈论这些Observer的时候，我们经常谈论在Observable chain结尾的最终的Observer。但是，每一个运算，例如map()和filter()，内部也实现了Observer。

下来，我们聚焦Observer的subscribe()方法。

Implementing and subscribing to an Observer

当你调用一个Observable的subscribe()方法，一个Observer通过实现这些方法，被用来消费这些三个事件。
我们能实现一个Observer，传递它的实例，传给subscribe()方法。先不要关注onSubscribe()，我们后面再讲：

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class Launcher {
    public static void main(String[] args) {
        Observable<String> source =
                Observable.just("Alpha", "Beta", "Gamma", "Delta", "Epsilon");
        Observer<Integer> myObserver = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                //没事做，忽视他
            }
            @Override
            public void onNext(Integer value) {
                System.out.println("RECEIVED: " + value);
            }
            @Override
            public void onError(Throwable e) {
                e.printStackTrace();
            }
            @Override
            public void onComplete() {
                System.out.println("Done!");
            }
        };
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(myObserver);        
    }
}

我们增加了一个Observer，它接收整数长度emissions。在Observable chain的结尾，我们的Observer接收emissions，在终点，我们消费了这些emissions。通过消费，他们达到处理过程的终点，他们被写进数据库，文本文件，服务器响应，在UI展示，或者只是在控制台打印。
我们预先声明一个Observer，在Observable chain的终点，把它传给subscribe()方法。
它的onNext()方法接收每个整数长度emission，打印它。这个简单的例子不会产生错误，但是如果Observable chain里发生了错误，将被传给我们的
onError()实现，打印Throwable的堆栈跟踪。最后，当源不再有更多的emissions，它将调用onComplete()，在控制台打印Done!。

Shorthand Observers with lambdas

上面实现Observer的代码冗长而又繁琐。幸好，subscribe()方法是重载的，可以接受三个事件的lambda参数。前面的例子，我们可以这样写：

    Consumer<Integer> onNext = i -> System.out.println("RECEIVED: " + i);
    Action onComplete = () -> System.out.println("Done!");
    Consumer<Throwable> onError = Throwable::printStackTrace;

可以把这三个lambda作为参数传给subscribe()方法：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source =
                Observable.just("Alpha", "Beta", "Gamma", "Delta",
                        "Epsilon");
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(i -> System.out.println("RECEIVED: " + i),
                        Throwable::printStackTrace,
                        () -> System.out.println("Done!"));        
    }
}

注意，subscribe()还有其他的重载。你可以忽略onComplete()，只实现onNext()和onError()。这样将不会执行onComplete()，有时候你确实不需要它：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source =
                Observable.just("Alpha", "Beta", "Gamma", "Delta",
                        "Epsilon");
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(i -> System.out.println("RECEIVED: " + i),
                        Throwable::printStackTrace);        
    }
}

你甚至可以忽略onError()，只实现onNext()：

import io.reactivex.Observable;
public class Launcher {
    public static void main(String[] args) {
        Observable<String> source =
                Observable.just("Alpha", "Beta", "Gamma", "Delta",
                        "Epsilon");
        source.map(String::length).filter(i -> i >= 5)
                .subscribe(i -> System.out.println("RECEIVED: " + i));        
    }
}

错误可能在Observable chain的任何地方发生，会被传播给onError()处理，然后终止Observable，不再有更多的emissions。如果你不指定onError的动作，错误就不会被处理。
大多数的subscribe()重载变种返回一个Disposable，我们都没做处理。Disposable允许我们断开到Observable的连接，这样可以早一些终止emissions，
这会无限的或者长时间运行的Observables至关重要。我们后面讨论disposables。