Android--RxJava

1 简介

RxJava本质上是一个异步操作库，是一个能让你用极其简洁的逻辑去处理繁琐复杂任务的异步事件库。
特点是链式调用，逻辑简单。（Git地址）

2 观察者模式

观察者模式基于Subject这个概念，Subject是一种特殊对象，又叫做主题或者被观察者。
当它改变时那些由它保存的一系列对象将会得到通知，而这一系列对象被称作Observer(观察者)。
它们会对外暴漏了一个通知方法，当Subject状态发生变化时会调用的这个方法。

观察者模式很适合下面这些场景中的任何一个：

1. 当你的架构有两个实体类，一个依赖另一个，你想让它们互不影响或者是独立复用它们时。
2. 当一个变化的对象通知那些与它自身变化相关联的未知数量的对象时。
3. 当一个变化的对象通知那些无需推断具体类型的对象时。

通常一个观察者模式的类图是这样的：

3 扩展的观察者模式

在RxJava中主要有4个角色：

• Observable
• Subject
• Observer
• Subscriber

Observable和Subject是两个“生产”实体，Observer和Subscriber是两个“消费”实体。说直白点Observable对应于观察者模式中的被观察者，而Observer和Subscriber对应于观察者模式中的观察者。Subscriber其实是一个实现了Observer的抽象类，后面我们分析源码的时候也会介绍到。Subject比较复杂，以后再分析。
观察者Observer和被观察者Observable通过subscribe()方法实现订阅关系。从而Observable 可以在需要的时候发出事件来通知Observer。

4 RxJava使用

创建观察者Observer

Observer<Object> observer = new Observer<Object>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Object s) {

    }
 };

RxJava中添加了普通观察者模式缺失的三个功能：

• RxJava中规定当不再有新的事件发出时，可以调用onCompleted()方法作为标示；
• 当事件处理出现异常时框架自动触发onError()方法；
• 同时Observables支持链式调用，从而避免了回调嵌套的问题。

创建被观察者Observable

Observable.create()方法可以创建一个Observable，使用crate()创建Observable需要一个OnSubscribe对象，这个对象继承Action1。当观察者订阅我们的Observable时，它作为一个参数传入并执行call()函数。

Observable<Object> observable = Observable.create(new Observable.OnSubscribe<Object>() {         
    @Override
    public void call(Subscriber<? super Object> subscriber) {

    }
});

除了create()，just()和from()同样可以创建Observable。看看下面两个例子：

just(T…)将传入的参数依次发送

Observable observable = Observable.just("One", "Two", "Three");
//上面这行代码会依次调用
//onNext("One");
//onNext("Two");
//onNext("Three");
//onCompleted();

from(T[])/from(Iterable<? extends T>)将传入的数组或者Iterable拆分成Java对象依次发送

String[] parameters = {"One", "Two", "Three"};
Observable observable = Observable.from(parameters);
//上面这行代码会依次调用
//onNext("One");
//onNext("Two");
//onNext("Three");
//onCompleted();

被观察者Observable订阅观察者Observer

有了观察者和被观察者，我们就可以通过subscribe()l，就像这来实现二者的订阅关系了。

observable.subscribe(observer);

一个完整的RxJava调用

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        for (int i = 0; i < 5; i++) {
            subscriber.onNext(i);
        }
        subscriber.onCompleted();
    }

}).subscribe(new Observer<Integer>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }

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

    @Override
    public void onNext(Integer item) {
        System.out.println("Item is " + item);
    }
});

使用Observable.create()创建了一个新的Observable，并为create()方法传入了一个OnSubscribe，OnSubscribe中包含一个call()方法，一旦我们调用subscribe()订阅后就会自动触发call()方法。call()方法中的参数Subscriber其实就是subscribe()方法中的观察者Observer。我们在call()方法中调用了5次onNext()和1次onCompleted()方法。一套流程周下来以后输出结果就是下面这样的：

Item is 0
Item is 1
Item is 2
Item is 3
Item is 4
onCompleted

异步

上一篇文章中开篇就讲到RxJava就是来处理异步任务的。但是默认情况下我们在哪个线程调用subscribe()就在哪个线程生产事件，在哪个线程生产事件就在哪个线程消费事件。那怎么做到异步呢？RxJava为我们提供Scheduler用来做线程调度，我们来看看RxJava提供了哪些Scheduler。

同时RxJava还为我们提供了subscribeOn()和observeOn()两个方法来指定Observable和Observer运行的线程。

Observable.from(getCommunitiesFromServer())
            .flatMap(community -> Observable.from(community.houses))
            .filter(house -> house.price>=5000000).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(this::addHouseInformationToScreen);