RxJava 从入门到精通

简介

Rxjava 是由微软架构师 Erik Meijer 领导的团队研发出来的开源库，目的是为了提供一个一致的编程接口，以便开发者对异步操作能够进行方便的处理。Rxjava 的设计是的开发者能通过 LINQ 的风格进行异步处理，所以它能将各种判断、循环、过滤、转换等的嵌套层级拉平，以流式的方式来编程，极大地简化了代码，增强了代码的阅读性。

如何使用 Rxjava

下面先举几个例子来说明一下 Rxjava 的简单使用，注意，每一个例子都是一个不同类型的使用方式，且包含了 Rxjava 不同的组成成分。

示例 01：简单示例

下面看一个 Rxjava 使用上的一个最简示例：

Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        emitter.onNext("a");
        emitter.onNext("b");
        emitter.onComplete();
    }
});
Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG,"onSubscribe");
    }
    @Override
    public void onNext(String s) {
        Log.d(TAG,s);
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG,"onError");
    }
    @Override
    public void onComplete() {
        Log.d(TAG,"onComplete");
    }
};
observable.subscribe(observer);
// ------------------- 打印结果 -------------
onSubscribe
a
b
onComplete

我们分析上面的示例，它包含两个对象和一个动作：被观察者（Observable）、观察者（Observer）和订阅动作 subscribe()。Rxjava 是以观察者模式为基础扩展而来的，如上示例所示，当观察者和被观察者通过订阅发生关联后，被观察者就是作为信号的发射方发射消息，而观察者接受被观察者发送来的消息。观察者的onSubscribe()方法是在subscribe()的时候便执行了，onNext()方法是被观察者执行emitter.onNext("a")发射数据的时候执行，当调用emitter.onComplete()时，观察者通过 onComplete()方法响应，当调用过程中出现某些异常时，onError(Throwable e)方法响应。

onSubscribe()的方法参数为一个 Disposable 对象，持有这个对象后，我们能够在任意位置通过调用d.dispose()停止观察者对被观察者的响应。原理我们后续再说。

示例 02：异步示例

下面我们看一个异步的示例：

Observable.just(1,2,3,4)
    .subscribeOn(Schedulers.newThread())
    .observeOn(Schedulers.computation())
    .map(new Function() {
        @Override
        public String apply(Integer integer) throws Exception {
            Log.d(TAG,"apply--" + Thread.currentThread().toString());
            return integer.toString();
        }
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Consumer() {
        @Override
        public void accept(String s) throws Exception {
            Log.d(TAG,"accept--" + s + "--" + Thread.currentThread().toString());
        }
    });
// -----------------打印结果如下 -------------------
apply--Thread[RxComputationThreadPool-1,5,main]
apply--Thread[RxComputationThreadPool-1,5,main]
apply--Thread[RxComputationThreadPool-1,5,main]
apply--Thread[RxComputationThreadPool-1,5,main]
accept--1--Thread[main,5,main]
accept--2--Thread[main,5,main]
accept--3--Thread[main,5,main]
accept--4--Thread[main,5,main]

这个示例中引入了异步的概念，我们发现，当 observeOn 被调用后便能够指定下一步的转换等操作的工作线程，每次指定都会生效。这个功能的实现便是 Rxjava 通过调度器 Schedulers 来实现的异步调用。AndroidSchedulers 是 rxandroid 提供的一个扩展，使得后续的执行会在 Android 主线程中执行。我们可以利用调度器对异步操作进行流式的编程，调度器也是 Rxjava 重要的组成成分。

示例 03：背压示例

下面是 Rxjava 背压的一个示例。背压是指如下的情况：被观察者产生信号而观察者接受信号，对于异步的调用流来说，如果被观察者产生的信号非常快，但是观察者消化的信号非常慢，那么就会造成信号的阻塞。而 rxjava 背压的设计解决了这个问题，下游可以控制上游信号的发射速度，从而解决消化不良的问题。

Flowable.create(new FlowableOnSubscribe() {
    @Override
    public void subscribe(FlowableEmitter emitter) throws Exception {
        for (int i = 0; i < 1000; i++) {
            emitter.onNext(i+ "");
        }

    }
}, BackpressureStrategy.BUFFER).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG,s);
    }
});

BackpressureStrategy.BUFFER是背压设计的一个模式，在这个模式下如果下游的观察者消费不了数据，那么就会无限增加缓存，直到产生 OOM，当然还有其他的背压模式。Rxjava 1.x 的版本并不是所有的 Observable 都支持背压，而 Rxjava 2.x 中 Observable 不再支持背压，而是改用 Flowable 来专门支持背压。 背压，也是 rxjava 的一个重要组成部分。

示例 04：Subject 代理示例

subject 可以看成是一个桥梁或者说代理，它既能充当观察者、也能充当被观察者。作为观察者，它能订阅一个或者多个被观察者，作为被观察者它能接收转发给它的数据然后再发射新的数据。下面举一个比较简单的示例:

AsyncSubject subject = AsyncSubject.create();
subject.onNext("subject01");
subject.onNext("subject02");
subject.onComplete();
subject.subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG,"onSubscribe_async");
    }
    @Override
    public void onNext(String s) {
        Log.d(TAG,s);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
        Log.d(TAG,"onComplete");
    }
});
// ------------------------------- 打印结果如下 --------------------------
onSubscribe_async
subject02
onComplete

AsyncSubject 只关注在 onComplete()调用前的最后一个数据，然后把数据发送给观察者。当然，还有一些其他类型的 Subject 来实现各式各样的功能，我们再后续的文章中会介绍到。

什么是观察者模式

观察者模式是当自身状态发生变化时能够自动通知所有依赖于它的对象的一种行为型模式。比如说电灯和开关的关系，开关属于被观察者，电灯属于观察者，电线则为连接两者的依赖关系。当开关的状态发生变化时，那么就会通过电线通知到绑定的电灯的开启状态。这就是一个比较简单的观察者模式。

下面我们就把电灯的这个观察者模式实现出来。

public class Light {
    private void doOpen() {
        // dosomething
    }
    private void doClose() {
        // do Something
    }
    public void update(boolean isOpen) {
        if (isOpen) {
            doOpen();
        }else {
            doClose();
        }
    }
}
public class Switch {
    // 一个开关可以控制许多个灯。
    List observers = new ArrayList<>();
    public void subscribe(Light light) {
        observers.add(light);
    }

    public void switchOnOff(boolean isOn) {
        for (Light light : observers) {
            light.update(isOn);
        }
    }
}

void main() {
    Light light = new Light();
    Light light02 = new Light();
    Switch switchOn = new Switch();
    switchOn.subscribe(light);
    switchOn.subscribe(light02);

    switchOn.switchOnOff(true);
}

上述是一个较为简单的观察者模式的设计。当开关状态发生变化时，会通知自己持有的灯的对象。

Rxjava 的组成成分

从第一节中举的那些例子来看，我们可以归纳一下 Rxjava 的组成成分。被观察者(Observable)、观察者(Observer)、调度器(Scheduler)、代理桥(Subject)、背压(使用 Flowable 实现)、如何将这些元素创建并连接起来，那就涉及到另外一个成分，就是操作符。如上面例子中的 Observable.just()就是一个创建操作符。另外还有 变换操作符、过滤操作符、条件操作符、布尔操作符、合并操作符和连接操作符等供我们使用。那我们就开始我们详细了解 RXjava 的步伐吧。

使用说明也可以参考 RxJava 的官方文档一起来看。ReactiveX 文档中文翻译

Rxjava 的操作符

Rxjava 有许多操作符来协助开发者更好的去开发功能，大致可以如下分类：

• 创建操作符
• 变换操作符
• 过滤操作符
• 条件操作符
• 布尔操作符
• 合并操作符
• 连接操作符

下面我们对这些操作符进行一下详细的介绍，每个操作符我都会举一个简单的例子以便加深对它的理解。

创建操作符

创建操作符的作用是创建一个被观察者（Observable）。

just(T item1, T item2,...)

Observable.just(1,2,3,4)
        .subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG,integer.toString());
            }
        });
// ---------------- 输出结果 -------------------
1
2
3
4

just 创建出来的被观察者会将参数中的值依次发给观察者，最后的打印结果便如上面所示。just 操作符最多只能有十个参数，创建的 Observable 会依次发射参数中的数据向 Observer，示例如上所示。

fromXXX()

这其中包含如下的方法调用，使用方式和 just 是一样的：

// 传入参数数量不限，一个一个发射给观察者
Observable.fromArray();
// 传入一个迭代器对象，如 list，会将其中的元素一个一个发射出去
Observable.fromIterable();
// 传入 Future 对象，最终会发生 Future.get()方法返回的参数。
Observable.fromFuture();
// 传入一个 Callable 对象
Observable.fromCallable();

defer()

每次订阅都会创造一个新的 Observable，然后重新发射数据。下面是使用示例：

Observable observable1 = Observable.defer(new Callable>() {
    @Override
    public ObservableSource call() throws Exception {
        return Observable.just("a","b","c");
    }
});
observable1.subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG,s+"001");

    }
});
observable1.subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG,s+"002");
    }
});
// ------------------- 打印结果如下 --------------------
a001
b001
c001
a002
b002
c002

我们可以发现，a b c 这三条讯息在第二次订阅的时候又被重新发了一遍,这些观察者实际上订阅的根本就不是同一个被观察者，每次发生订阅事件，都会 return 一个新的被观察者对象（Observable.just("a","b","c")），而这个被观察者是在订阅的那一瞬间才创建的，这样能够保证订阅数据的实时性。

Empty/Never/Throw

这三个的功能都比较简单，在测试的时候会经常用到。

• Empty 创建一个不发射任何数据但是正常终止的 Observable，最终只调用 onSubscribe 和 onComplete 方法
• Never 创建一个不发射数据也不终止的 Observable，只会调用 onSubscribe 方法。
• Throw 创建一个不发射数据然后一个错误终止的 Observable，只会调用 onSubscribe 和 onError 方法。

下面的示例发射空的，打印结果如下，最终也不会去调用 onNext() 方法。

Observable.empty().subscribe(new Observer