Rxjava在github上的自我介绍是”RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.”一个JVM上使用可观测的序列来组成异步的、基于事件的程序的库。
总结起来,它是一个实现异步操作的库,是通过一种扩展的观察者模式来实现的。android的点击事件就是一种观察者模式, 通过setOnClickListener()方法,Button持有OnClickListener的引用,当用户点击Button时,Button会自动调用OnClickListener的onClick()。
- Button → 被观察者
- OnClickListener → 观察者
- setOnClickListen() → 订阅
- onClick() → 事件
Rxjava观察者模式
Rxjava也有对应的概念:
- 被观察者:Observable
- 观察者:Observer、Subscriber
- 订阅:subscribe()
- 事件:onNext() onCompleted() onError()
Observable 与 Observer (Subscriber)通过 subscribe() 方法实现订阅关系,从而 Observable 可以在需要的时候发出事件来通知 Observer (Subscriber)。
与传统观察者模式不同, RxJava 的事件回调方法除了普通事件 onNext() 之外,还定义了两个特殊的事件:onCompleted() 和 onError()。
- onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的 onNext() 发出时,需要触发 onCompleted() 方法作为标志。
- onError(): 事件队列异常。在事件处理过程中出异常时,onError() 会被触发,同时队列自动终止,不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个,并且是事件序列中的最后一个。需要注意的是,onCompleted() 和 onError() 二者也是互斥的,即在队列中调用了其中一个,就不应该再调用另一个。
基本实现
Rxjava的实现主要有三点:创建 Observer、创建 Observable、Subscribe (订阅)
Observer
Observer 即观察者,它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer 接口的实现方式:
Observer<T> observer = new Observer<T>(){
@Override
public void onNext(T t){
Log.d(tag, "Next");
}
@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<T> subscriber = new Subscribe<T>(){
@Override
public void onNext(T t){
Log.d(tag, "Next");
}
@Override
public void onCompleted() {
Log.d(tag, "Completed");
}
@Override
public void onError(Throwable e) {
Log.d(tag, "Error");
}
};
不仅基本使用方式一样,实质上,在 RxJava 的 subscribe 过程中,Observer 也总是会先被转换成一个 Subscriber 再使用。们的区别对于使用者来说主要有两点:
- onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或重置。这是一个可选方法。
- unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法,用于取消订阅。在这个方法被调用后,Subscriber 将不再接收事件。一般在这个方法调用前,可以使用 isUnsubscribed() 先判断一下状态。
Observable
Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。RxJava 使用 create() 方法来创建一个 Observable ,并为它定义事件触发规则:
Observable observable = Observable.create(new Observable.OnSubscribe<T>(){
@Override
public void call(Subscriber<? super T> subsctriber){
subscriber.onNext(t1);
subscriber.onNext(t2);
subscriber.onCompleted();
}
})
可以看到,这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中,它的作用相当于一个计划表,当 Observable 被订阅的时候,OnSubscribe 的 call() 方法会自动被调用,事件序列就会依照设定依次触发。
create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法, RxJava 还提供了一些方法用来快捷创建事件队列:
- just(T…): 将传入的参数依次发送出来
Observable observable = Observable.just(t1, t2);
等价于
onNext(t1);
onNext(t2);
onCompleted(); - from(T[]) : 将传入的数组拆分成具体对象后,依次发送出来
T[] ts = {t1, t2};
Observable observable = Observable.from(ts);
等价于
onNext(t1);
onNext(t2);
onCompleted();
Subscribe
创建了 Observable 和 Observer 之后,再用 subscribe() 方法将它们联结起来,整条链子就可以工作了:
observable.subscribe(observer);
observable.subscribe(subscriber);
observable.subscribe(Subscriber) 的内部实现的核心代码是:
public Subscription subscribe(Subscriber subscriber) {
subscriber.onStart();
onSubscribe.call(subscriber);
return subscriber;
}
可以看到,subscriber() 做了3件事:
- 调用 Subscriber.onStart()
- 调用 Observable 中的 OnSubscribe.call(Subscriber)
- 将传入的 Subscriber 作为 Subscription 返回
快速实现
ActionX
- Action0 是 RxJava 的一个接口,它只有一个方法 call(),这个方法是无参无返回值的
由于 onCompleted() 方法也是无参无返回值的,因此 Action0 可以被当成一个包装对象,将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。
Action0 onCompletedAction = new Action0() {
// onCompleted()
@Override
public void call() {
Log.d(tag, "completed");
}
};
observable.subscribe(onCompletedAction);
- Action1 也是一个接口,它同样只有一个方法 call(T param),这个方法也无返回值,但有一个参数
由于 onNext(T obj) 和 onError(Throwable error) 也是单参数无返回值的,因此 Action1 可以将 onNext(obj) 和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调。
Action1<T> onNextAction = new Action1<T>() {
// onNext()
@Override
public void call(T t) {
Log.d(tag, "Next");
}
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
// onError()
@Override
public void call(Throwable throwable) {
Log.d(tag, "Error");
}
};
observable.subscribe(onNextAction, onErrorAction);
FuncX
FuncX 和 ActionX 非常相似,也是 RxJava 的一个接口,用于包装含有一个参数的方法。二者的区别在 FuncX 包装的是有返回值的方法。
Rxjava API
线程控制
在不指定线程的情况下, RxJava 遵循的是线程不变的原则,即:在哪个线程调用 subscribe(),就在哪个线程生产事件;在哪个线程生产事件,就在哪个线程消费事件。而Scheduler 相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 内置的 Scheduler:
- Schedulers.immediate(): 直接在当前线程运行,相当于不指定线程。
- Schedulers.newThread(): 总是启用新线程,并在新线程执行操作。
- Schedulers.io(): I/O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。内部实现是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。
- Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算。内部实现是使用的固定的线程池,大小为 CPU 核数。
- AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。
Rxjava通过使用subscribeOn() 和 observeOn() 两个方法来对线程进行控制。
- subscribeOn(): 指定 subscribe() 所发生的线程,即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。
- observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
Observable.just(1, 2, 3, 4)
.subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer number) {
Log.d(tag, "number:" + number);
}
});
变换
map()
map() 方法将参数中的前面的对象转换成一个后面的对象后返回,而在经过 map() 方法后,事件的参数类型也由前对象转为了后面的对象。
Observable.just("images/logo.png") // 输入类型 String
.map(new Func1<String, Bitmap>() {
@Override
public Bitmap call(String filePath) { // 参数类型 String
return getBitmapFromPath(filePath); // 返回类型 Bitmap
}
})
.subscribe(new Action1<Bitmap>() {
@Override
public void call(Bitmap bitmap) { // 参数类型 Bitmap
showBitmap(bitmap);
}
});
flatMap()
flatMap() 和 map() 有一个相同点:它也是把传入的参数转化之后返回另一个对象。但需要注意,和 map() 不同的是, flatMap() 中返回的是个 Observable 对象,并且这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。
flatMap() 的原理是这样的:
1. 使用传入的事件对象创建一个 Observable 对象;
2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;
3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。
这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象“铺平”之后通过统一路径分发了下去。而这个“铺平”就是 flatMap() 所谓的 flat。
Student[] students = ...;
Subscriber<Course> subscriber = new Subscriber<Course>() {
@Override
public void onNext(Course course) {
Log.d(tag, course.getName());
}
...
};
Observable.from(students)
.flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getCourses());
}
})
.subscribe(subscriber);