RxJava的观察者模式

RxJava有四个基本概念：Observale(被观察者)、Observer(观察者)、subscribe(订阅)、事件。
Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
与传统观察者模式不同，RxJava的事件回调方法除了普通事件onNext()之外，还定义了两个特殊的事件：onCompleted()和onError()。

onCompleted(): 事件队列完结。RxJava不仅把每个事件单独处理，还会把它们看做一个队列。RxJava规定，当不会再有新的onNext()发出时，需要触发onCompleted()方法作为标志。
onError():事件队列异常。在事件处理过程中出异常时，onError()会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中，onCompleted()和onError()有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted()和onError()是互斥的，即在队列中调用了其中一个，就不应该再调用另外一个。

基本使用

创建 Observer

Observer 即观察者，它决定事件触发的时候将有怎样的行为。 RxJava 中的Observer接口的实现方式：

Observer<String> observer = new Observer<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

除了Observer接口之外，RxJava 还内置了一个实现了Observer的抽象类：Subscriber。Subscriber对Observer接口进行了一些扩展，但他们的基本使用方式是完全一样的：

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

不仅基本使用方式一样，实质上，在RxJava的subscribe(订阅)过程中，Observer也总是会先被转换成一个Subscriber再使用。所以如果只想使用基本功能，选择Observer和Subscriber是完全一样的。它们的区别对于使用者来说主要有两点：

onStart():这是Subscriber增加的方法。它会在subscribe(订阅)刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行），onStart()就不适用了，因为它总是在subscribe(订阅)所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用doOnSubscribe（）方法，具体可以在后面的文章中看到。
unsubscribe():这是Subscriber所实现的另外一个接口Subscription的方法，用于取消订阅。在这个方法被调用后，Subscriber将不再接收事件。一般在这个方法调用前，可以使用isUnsubscribed()先判断一下状态。isUnsubscribed()这个方法很重要，因为在subscribe()之后，Observable会持有Subscriber的引用，这个引用如果不能及时被释放，将有内存泄漏的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（如onPause()、onStop()等方法中）调用unsubscribe来解除易用关系，以避免内存泄漏的发生。

创建Observable

Observable就是被观察者，它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create()
方法来创建一个 Observable ，并为它定义事件触发规则：

//定义被观察者，
Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        if (!subscriber.isUnsubscribed()) {
            subscriber.onNext("hello");
            subscriber.onNext("hi");            
            subscriber.onNext("world");
            subscriber.onCompleted();
        }
    }
});

我们可以看到，Observable的创建是使用create()，并且传入了一个OnSubscribe对象作为参数。OnSubscribe会被存储在返回的Observable对象中，它的作用相当于一个计划表，当Observable被订阅的时候，OnSubscribe和call方法会自动被调用，事件序列就会依照设定依次触发。

这个例子很简单：事件的内容是字符串，而不是一些复杂的对象；事件的内容是已经定好了的，而不像有的观察者模式一样是待确定的（例如网络请求的结果在请求返回之前是未知的）；所有事件在一瞬间被全部发送出去，而不是夹杂一些确定或不确定的时间间隔或者经过某种触发器来触发的。总之，这个例子看起来毫无实用价值。但这是为了便于说明，实质上只要你想，各种各样的事件发送规则你都可以自己来写。至于具体怎么做，后面都会讲到，但现在不行。只有把基础原理先说明白了，上层的运用才能更容易说清楚。

create()方法是RxJava最基本的创造事件序列的方法。基于这个方法，RxJava还提供了一些方法用来快捷创建事件队列，例如：

• just（T...）:将传入的参数依次发送出来

String[] item1 = {"hello","world"};
String[] item2 = {"RxJava", "just"};
Observable observable = Observable.just(item1, item2);
//将会依次调用:
//onNext("hello");
//onNext("world");
//onNext("RxJava");
//onNext("just");
// onCompleted();

• from(T[])/from(Iterable<? extends T>):将传入的数组或者Iterable拆分成具体对象后，依次发送出来

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

Subscribe(订阅)

创建了Observable和Observer之后，再用subscribe()方法将它们联结起来，就可以工作了：

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

Observable.subscribe(Subscriber)内部实现是这样的：

// 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码，可以去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart();
    onSubscribe.call(subscriber);
    return subscriber;
}

可以到看到，subscriber()做了3件事：

1.调用subscriber.onStart();
2.调用Observable中的OnSubscribe.call(subscriber)。在这里，事件发送的逻辑开始运行。从这也可以看出，在RxJava中，Observable并不是在创建的时间就立即开始发送事件，而是在它被订阅的时候，即当subscribe()方法执行的时候。
3.将传入的subscriber返回。这是为了方便unsubscribe();

整体流程

整体流程

不完整定义的回调

除了subscribe(Observer)和subscribe(Subscriber),subscribe()还支持不完整定义的回调，RxJava会自动根据定义创建出Subscribeer。

Action1<String> onNextAction = new Action1<String>() {
    // onNext()
    @Override
    public void call(String s) {
        Log.d(tag, s);
    }
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    // onError()
    @Override
    public void call(Throwable throwable) {
        // Error handling
    }
};
Action0 onCompletedAction = new Action0() {
    // onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
observable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

简单解释一下这段代码中出现的 Action1 和 Action0。
Action0:Action0是RxJava中的一个接口，它只有一个call()方法，这个方法是无参无返回值的；由于Subscriber中的onCompleted()方法也是无参无返回值的，因此Action0可以被当作一个包装对象，将onCompleted()的内容打包起来将自己作为一个参数传入subscribe()以实现不完整定义的回调。这样也就相当于把onCompleted()方法作为参数传进了subscribe()。
Action1:Action1也是RxJava中的一个接口，它同样也只有call(T param)一个方法，这个方法也无返回值，但有一个参数；与Action0同理，由于onNext(T obj)和onError(Throwable e)也是单参数无返回值的，因为Action1可以将onNext(T obj)和onError(Throwable e)打包起来传入subscribe()以实现不完整定义的回调。事实上，虽然 Action0 和 Action1 在 API 中使用最广泛，但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的，它们可以被用以包装不同的无返回值的方法。

举例

打印字符串数组

String[] names = ...;
Observable.from(names)
    .subscribe(new Action1<String>() {
        @Override
        public void call(String name) {
            Log.d(tag, name);
        }
    });

由 id 取得图片并显示

//由指定的一个 drawable 文件 id drawableRes 取得图片，并显示在 ImageView 中，并在出现异常的时候打印 Toast 报错：
int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
}).subscribe(new Observer<Drawable>() {
    @Override
    public void onNext(Drawable drawable) {
        imageView.setImageDrawable(drawable);
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable e) {
        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();
    }
});