RxJava 定义
** a library for composing(组成) asynchronous and event-based programs using observable sequences for the java VM (一个在 Java VM 上使用可观测的序列来组成的异步的、基于事件的程序的库);**
RxJava 优点
简洁:异步操作很关键的一点是程序的简洁性,因为在调度过程比较复杂的情况下,异步代码经常会既难写又难被读懂。Android 创造的AsyncTask
和Handler
,其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁,但它的简洁与众不同之处在于,随着程序逻辑变得越来越复杂,它依然能够保持简洁。
API 介绍和原理分析
1. 概念:扩展的观察者模式
- RxJava 的异步实现,是通过一种扩展的观察者模式来实现的。
观察者模式:观察者模式面向的需求是:A 对象(观察者)对 B 对象(被查观察者)的某种变化高度敏感,需要在 B 变化的一瞬间做出反应。程序的观察者模式,观察者不需要时刻盯着被观察者,而是采用注册(Register)或者称为订阅(Subscribe)的方式,告诉被观察者:我需要你的某某状态,你要在它变化的时候通知我。Android 开发中一个比较典型的日子是点击监听器OnClickListener
。对设置OnClickListenr
来说,View
是被观察者,OnClickListenr
是观察者,二者通过setOnClickListener
方法达成订阅关系。订阅之后用户点击按钮的瞬间,AndroidFrameWork 就会将点击事件发送给已经注册的OnClickListenr
。采取这样被动的观察方式,既省去了反复检索状态的资源消耗,也能够得到最高的反馈速度。
2. RxJava 的观察者模式
RxJava 有四个基本概念:
Observable
(可观察者,即被观测者)Observer
(观察者)Subscribe
(订阅)Event
(事件)
Observable
和Observer
通过suscribe()
方法实现订阅关系,从而Observable
可以在需要的时候发出事件来通知Observer
。与传统观测者模式不同,RxJava 的事件回调除了普通事件onNext()
(相当于onClick()
和onEvent()
)之外,还定义了俩个特殊的事件:onCompleted()
和onError()
:
onCompleted()
:事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的onNext()
发出时,需要触发onCompleted()
方法作为完成标识。onError()
:事件队列异常。在事件处理过程中出现异常时,onError()
会被触发,同时队列自动终止,不允许再有事件发出。- 在一个正确运行的事件序列中,
onCompleted()
和onError()
有且只有一个,并且是事件序列中的最后一个调用。需要注意的是,onCompleted()
和onError()
二者也是互斥的,即在队列中调用了其中一个,就不该在调用另一个。RxJava 的观察者模式大致如下: Observable–》onNext()/onCompleted() or onError()–》Observer;
3. 基本实现:
1. 创建Observer
Observer
即观察者,它决定事件触发的时候将有怎样的行为。RxJava 的Observer
接口的实现方式:
1 | Observer<String> observer = new Observer<String>() { |
除了Observer
接口之外,RxJava 还内置了一个实现了Observer
的抽象类:Subscriber
。Subscriber
对Observer
接口进行了一些扩展,但他们的基本使用方式是完全一样的:
1 | Subscriber<String> subscriber = new Subscriber<String>() { |
不仅基本使用方式一样,实质上,在 RxJava 的Subscribe
过程中,Observer
也总是会被先转换成一个Subscriber
再使用。他们之间的区别主要有俩点:
onStart()
: 则是Subscriber
增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或者重置。这个是一个可选方法,默认情况下它的实现为空。需要注意的是,如果对准备工作的线程有要求(例如弹窗一个显示进度的对话框,这必须在主线程执行),onStart()
就不实用了,因为它总是在subscribe
所发生的线程(子线程)中被调用,而不能指定。要在指定的线程来做准备工作,可以使用doOnSubscribe()
方法。unsubscribe()
:这是Subscriber
所实现的另一个接口Subscription
的方法,用于取消订阅。在这个方法被调用后,Subscriber
将不在接收事件。一在这方法调用前,可以使用isUnsubscribed()
先判断一下状态。unsubscribe()
这个方法很重要,因为在subscribe()
之后,Observable
会持有Subscriber
的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快的在合适的地方(例如onPause()、onStop()
等方法中)调用unsubscribe()
来解除关系,以避免内存泄露的发生。
2. 创建 Observable
Observable
即被观察者,它决定什么时候触发事件以及触发怎么样的事件。RxJava 使用create()
方法来创建一个Observable
,并为他定义事件触发规则:
1 | Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() { |
可以看到这里传入了一个OnSubscribe
对象作为参数。OnSbuscribe
会被存储在返回的Onservable
对象中,它的作用相当于一个计划表,当Obervable
被订阅的时候,OnSubscribe
的call()
方法会自动被调用,事件序列就会依照设定顺序依次触发。这样,由被观察者调用了观察者的回调方法,就实现了由被观察者向观察者的事件传递,即观察者模式。
create()
方法是 RxJava 最基本的创造事件序列的方法。基于这个方法,RxJava 还提供了一些方法用来快捷创建事件队列,例如:just(T...)
将传入的参数依次发送出来:
1
//被观察者的创建方式2:just() 将传入的参数依次发送出来
Observable<String> observable1 = Observable.just("Hello", "World!", "RxJava");
// 将会依次调用:
// onNext("Hello");
// onNext("World!");
// onNext("RxJava");
// onCompleted();
1
2 * `from(T[])/from(Iterable(? extend T))`将传入的数组或者Iterable拆分成具体对象后发送出来
~~~java
//被观察者的创建方式3:from(T[])/from(Iteraable< ? extends T>) 将传入的数组或者Iterable拆分成具体对象后发送出来
String[] words = {"Hello", "World!", "RxJava"};
Observable observable2 = Observable.from(words);
// 将会依次调用:
// onNext("Hello");
// onNext("World!");
// onNext("RxJava");
// onCompleted();
1
上面三种方式创建被观察者 Obersvable 对象,是等价的!
3. Subscribe(订阅)
创建了Observable
和Observer
对象之后,再用subscribe()
方法将他们连接起来,整条工作链就完成了。
代码很简单:
1 observable.subscribe(subscriber);
//or
observable.subscribe(observer);
1
2
3
4
5 **`Observable.subscribe(Subscriber)`的内部实现功能核心伪代码**
~~~java
// 注意:这不是 subscribe() 的源码,而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码,可以去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) {
subscriber.onStart();
onSubscribe.call(subscriber);
return subscriber;
}
1
2
3
4
5
6
7
8
9 这里`subscribe()`做了3件事:
* 调用`Subscriber.onStart()`.
* 调用`Observable`中的OnSubscribe.call(Subscriber)`。
* 将传入的`Subscriber`作为`Subscription`返回。这是为了方便`unsubscribe()`;

除了`subscribe(Observer)`和`subscribe(subscriber)`,`subscribe()`还支持不完整定义的回调,RxJava会自动根据定义创建出Subscriber。
形式如下:
~~~java
Action1<String> onNextAction = new Action1<String>() {
@Override
public void call(String s) {
Log.d(TAG, "call() called with: " + "s = [" + s + "]");
}
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Log.d(TAG, "call() called with: " + "throwable = [" + throwable + "]");
}
};
Action0 onCompletedAction = new Action0() {
@Override
public void call() {
Log.d(TAG, "call() called with: " + "completed");
}
};
//自动创建 Subscriber,并使用 onNextAciton 来定义 onNext();
observable.subscribe(onNextAction);
//自动创建 Subscriber,并使用 onNextAciton 和 onErrorAciton,来定义 onNext()和 onError();
observable.subscribe(onNextAction, onErrorAction);
//自动创建 Subscriber,并使用 onNextAction 来定义 onNext(),使用 onErrorAciton 来定义 onError(),使用 onCompletedAction 来定义 onCompleted()
observable.subscribe(onNextAction,onErrorAction,onCompletedAction);
1 `Action0` 是 RxJava 的一个接口,它只有一个方法 `call()`,这个方法是无参无返回值的;由于 `onCompleted()` 方法也是无参无返回值的,因此 `Action0` 可以被当成一个包装对象,将 `onCompleted()` 的内容打包起来将自己作为一个参数传入 `subscribe()` 以实现不完整定义的回调。这样其实也可以看做将`onCompleted()` 方法作为参数传进了 `subscribe()`,相当于其他某些语言中的『闭包』。 `Action1` 也是一个接口,它同样只有一个方法 `call(T param)`,这个方法也无返回值,但有一个参数;与 `Action0` 同理,由于 `onNext(T obj)` 和 `onError(Throwable error)` 也是单参数无返回值的,因此 `Action1` 可以将 `onNext(obj)` 和 `onError(error)` 打包起来传入 `subscribe()` 以实现不完整定义的回调。事实上,虽然 `Action0` 和 `Action1` 在 API 中使用最广泛,但 RxJava 是提供了多个 `ActionX` 形式的接口 (例如 `Action2`, `Action3`) 的,它们可以被用以包装不同的无返回值的方法。
4. 场景展示
- 打印字符串数组:
1 | /** |
- 使用 RxJava 的方式设置一张图片
1 | /** |
如上所示:创建出Observable
和Suberver
,再用subscribe()
将他们串起来,一次 RxJava 的基本使用就完成了。
然而,在 RxJava 的默认规则中,事件的发出和消费都是在同一个线程。也就是说,如果只用上面的方法,实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是:后台处理,前台回调 的异步机制,因此异步对于 RxJava 是至关重要的。而实现异步,这需要用到 RxJava 的另一个概念:Scheduler
。
5. 线程控制–Scheduler
在不指定线程的情况下,RxJava 遵循的是线程不变的原则,即:在那个线程调用subscribe()
,就在那个线程生产事件;在那个线程生产事件,就在那个线程消费事件。如果需要切换线程,就需要用到scheduler()
调度器。
Scheduler 的 API:在 RxJava 中,Scheduler
–调度器,相当于线程控制器,RxJava 通过它来指定每一段代码运行在什么样的线程。RxJava 已经内置了几个 Scheduler。它们已经适合大多数使用场景:
Schedulers.immediate()
:直接在当前线程运行,相当于不指定线程。这是默认的Scheduler
。
Schedulers.newThread()
:总是启用新线程,并在新线程执行操作。Schedulers.io()
:I/0 操作(读写文件、读写数据库、网络信息交互等)所使用的Scheduler
。行为模式和newThread()
差不多,区别在于io()
的内部实现是使用了一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下io()
比newThread()
更有效率。不要把计算工作放在io()
中,可以避免创建不必要的线程。Schedulers.computation():计算所使用的
Scheduler。这个计算指的是CPU密集型计算,即不会被I/O等操作限制性能的操作,例如图形的计算。这个
Scheduler使用固定的线程池,大小为CPU核数。不要把I/O操作放在
computation()`中,否者 I/O 操作的等待事件浪费 CPU。- 另外,Android 还有个一个专用的
AndroidSchedulers.mainThread()
,它指定的操作将在 Android 主线程运行。
有了这几个Scheduler
,就可以使用subscribeOn()
和observeOn()
俩个方法来对线程进行控制了。
subscribeOn()
:指定subscribe()
发生的线程,即Observable.OnSubscribe
被激活时所处的线程。或者叫做事件产生的线程。
observeOn()
:指定Subscriber
所运行的线程,或者叫做事件消费的线程。
1 | /** |
上面这段代码中,由于subscribeOn(Schedulers.io())
的指定,被创建的事件的内容 1/2/3/4 将会在 IO 线程发出;而由于observeOn(AndroidSchedulers.mainThread())
的指定,因此subscriber
数字的打印将发生在主线程中。事实上,这种在subscribe()
之前加上subscribeOn(Scheduler.io)
和observeOn(AndroidSchedulers.mainThread())
的使用方式非常常见,它适用于多数的【后台线程获取数据,主线程显示】的程序策略。
优化前面加载图片的例子:
1 | /** |
加载图片将会发生在 IO 线程,而设置图片则被设定在了主线程。这就意味着,即使加载图片好黑了几十甚至几百毫秒的事件,也不会造成界面的卡顿。