Android框架源码分析——RxJava源码分析
1、基本订阅流程
- 使用实例
Observable.create(ObservableOnSubscribe<String> { e -> e.onNext("A") })
.subscribe(object : Observer<String>{
override fun onComplete() {
}
override fun onSubscribe(d: Disposable) {
}
override fun onNext(t: String) {
}
override fun onError(e: Throwable) {
}
})
- RxJava的使用很简单概括为3个流程：
- 创建被观察者实例发送事件
- 创建观察者实例监听处理事件
- 被观察者订阅观察者，订阅成功后被观察者发送事件
2、源码分析
2.1、Observable创建
Observable的基本使用是调用Observable.create()，create()最终创建的Observable的实现类ObserveCreate，封装传入的ObservableOnSubscribe，ObservableOnSubscribe负责最终的事件发送
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
- ObserveCreate：继承Observable类，在内部保存创建时传入的ObservableOnSubscribe实例
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source; //保存传入参数
}
}
2.2、创建观察者实例
- 实现Observer接口的实例
interface Observer<T>
2.3、订阅观察者
public final void subscribe(Observer<? super T> observer) {
observer = RxJavaPlugins.onSubscribe(this, observer); //保存观察者
subscribeActual(observer); //执行观察者的subscribeActual抽象方法，从上面知道这里执行的是ObservableCreate（）中重写的抽象方法
}
}
Observable.subscribe(Observer observer)中主要作了两件事：
- 封装并保存下游设置的观察者Observer实例，在接收事件及时响应事件
- 执行被观察者的subscribeActual（）触发Observable发送事件，这里执行的是 ObservableCreate.subscribeActual（）
- subscribeActual（）：此处调用的是ObservableCreate中实现的方法
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
source.subscribe(parent);
}
subscribeActual（）中主要作以下3件事：
- 创建CreateEmitter包装观察者
- 执行调用观察者的onSubscribe方法,传入CreateEmitter实例，用于在请求时可以使用此对象控制或终止事件发送
- 执行传入的source.subscribe（）开始发送事件，这里传入的是封装后的观察者
- ObservableOnSubscribe.subscribe()：执行onNext（）发送事件
ObservableOnSubscribe<String> { e -> e.onNext("A") } //此处的e为CreateEmitter实例
- CreateEmitter.onNext()：调用观察者的方法响应事件
@Override
public void onNext(T t) {
if (!isDisposed()) { //检查是否取消订阅事件
observer.onNext(t); //（1）响应接收事件
}
}
@Override
public void onComplete() { //响应onComplete事件
if (!isDisposed()) {
observer.onComplete();
}
}
@Override
public void onError(Throwable t) { //响应onError事件
}
事件发送从调用传入CreateEmitter的next（），在next（）中直接调用Observer的onNext（）响应发送的事件，这里的Observer就是前面订阅时传入的，此处可以看出发送的事件onNext（）、onComplete（）、onError（）事件和观察者监听事件一一对应；
3、复杂订阅流程
上面的整个流程是最基本的订阅流程，即一层发送事件一层观察事件，虽然简单但却是RxJava的原理所在，很多复杂的程序也是利用此原理一步一步封装拓展过来的，在他们的内部是很多层简单的逻辑，下面分析复杂的流程是如何实现的：
Observable.create(object:ObservableOnSubscribe<String>{ //第一个Observable
override fun subscribe(e: ObservableEmitter<String>) {
e.onNext("A")
}
}).map(object : Function<String,String>{ //第二个Observable
override fun apply(t: String): String {
return "a"
}
}).flatMap { Observable.just("A -> a”)} 第三个Observable
.subscribe(object : Observer<String>{…})
由上面的分析知道，事件订阅是由下向上一次传递的过程，首先还是从订阅subscribe开始分析，由上面知道订阅观察者在包装Observer的同时，会触发执行订阅的Observable的subscribeActual()，此处为第三个Observable对象，flatMap（）对应Observable具体实现类为ObservableFlatMap
AbstractObservableWithUpstream(ObservableSource<T> source) {
this.source = source;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
从ObservableFlatMap的构造函数中看出内部保存着source实例，使用flatMap（）时会创建ObservableFlatMap实例并传入上面创建的被观察者实例，在subscribeActual（）中首先封装传入的Observer，再向上调用subscribe（）并传入MergeObserver观察者，此处的mapper就是flatMap中设置的转换方法
- ObservableMap
ObservableFlatMap的subscribe（）方法向上调用，同样会触发上级Observable的subscribeActual（），向上一层执行的是map（）操作符，map（）的具体实现类是ObservableMap，ObservableMap中像ObservableFlatMap保存着上游的被观察者实例和下游的观察者实例，而且在subscribeActual（）中同样封装Observer并调用subscribe（）向上传递
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source); // 保存传入的被观察者source
this.function = function; //保存map中设置的function
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function)); //（1）步骤和上面一样，先封装下游传入的观察者继续向上调用，并传递MapObserver
}
经过map向上调用，程序再次进入ObservableCreate中，从上面分析我们知道ObservableCreate中会执行事件的发送，并触发Observer的响应，此处第一层响应的观察者即为MapObserver
- MapObserver
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual); //（1）保存下游传来的Observer
this.mapper = mapper; //（1）在创建map时保存传入的转换方法
}
@Override
public void onNext(T t) {
U v;
try { // （2）执行设置Function方法，获取 经过方法处理后的数据
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
actual.onNext(v); //（3）调用下游Observer的onNext（）
}
前面的分析知道，MapObserver中保存这下游传递的观察者observer和map中设置的转换方法mapper，发送事件后执行到MapObserver的onNext（）中，onNext（）中首先执行mapper方法转换发送的事件，然后调用 actual.onNext(v)向下游传递事件
- MergeObserver：在flatMap（）中创建的
MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper,boolean delayErrors, int maxConcurrency, int bufferSize) {
this.actual = actual;
this.mapper = mapper; /
this.observers = new AtomicReference<InnerObserver<?, ?>[]>(EMPTY);
}
@Override
public void onNext(T t) {
ObservableSource<? extends U> p;
try { //（2）调用设置的Function方法，此时返回的是另一个Observable对象
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
return;
}
subscribeInner(p); //
}
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
for (;;) {
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++); //创建观察者
if (addInner(inner)) {
p.subscribe(inner); //（3）flapMap返回的是一个新的Observable，所以此处为新的Observer订阅观察者，（单层的整个订阅流程在flatMap（）内部再走一次）
}
break;
}
}
//InnerObserver
InnerObserver(MergeObserver<T, U> parent, long id) {
this.id = id;
this.parent = parent; //保存MergeObserver观察者
}
@Override
public void onNext(U t) {
parent.drain(); //（4）新的Observable订阅后响应观察者，调用MergeObserver的drain（）
}
void drainLoop() {
final Observer<? super U> child = this.actual;
child.onNext(o);
}
经上游传递方法执行到MergeObserver的onNext（），onNext（）中首先执行转换方法，因为faltMap中转换后返回新的Observable实例，所以在MergeObserver中会创建新的Observer对象即InnerObserver，然后对新的Observable对象订阅InnerObserver对象，发送的事件会执行到InnerObserver.onNext()中，然后调用MergeObserver的drain（），在drain中获取下游的Observer执行onNext（）事件继续向下传递，方法到此执行到了订阅的Observer中，响应onNext（）接收事件，最后的Observe接收事件！
4、基本操作符源码
4.1、just（）
just（）方法用于传递单个数据，在使用just（）操作符后会创建ObservableJust实例，基本功能和其他Observable一样，在subscribeActual（）中会执行run（），run（）方法中调用observer.onNext(value)发送事件
protected void subscribeActual(Observer<? super T> s) {
ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value); //（1）封装观察者和数据
s.onSubscribe(sd); //
sd.run(); //（2）执行发送内部的run（）
}
@Override
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
observer.onNext(value); //（3）接收发送事件
}
}
4.2、ObservableFromArray
ObservableFromArray和ObservableJust功能一致，只是ObservableFromArray允许发送多个数据，在ObservableFromArray的run（）方法中会循环依次发送数据
@Override
public void subscribeActual(Observer<? super T> s) {
FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array); （1）
s.onSubscribe(d);
d.run();
}
void run() {
T[] a = array;
int n = a.length;
for (int i = 0; i < n && !isDisposed(); i++) { //（2）循环发送事件
T value = a[i];
actual.onNext(value);
}
if (!isDisposed()) {
actual.onComplete();
}
}
4.3、map（）
由前面的源码分析知道map（）操作符创建的是ObservableMap的被观察者，其中主要执行三个操作：
- 创建ObservableMap中的观察者MapObserver的实例，保存下游传入的Observer和map（）中设置的Function实例
- 调用父类Observable的subscribe（）发送事件
- 在接收事件后，在MapObserver的onNext（）中先调用Function.apply()执行数据转换，然后将结果下发到下游Observer中
4.4、 flatMap（）
具体的执行逻辑和map（）一致，只是在Observer中处理不同，因为flatMap返回的是一个新的Observable，所以要对新的被观察者进行订阅观察，在接受新的事件后调用下层的观察者发送事件
4.5、 zip（）
将多个Observable的事件组合一一对应发送,zip（）操作符最终会创建ObservableZip实例，查看ObservableZip方法
public void subscribeActual(Observer<? super R> s) {
ObservableSource<? extends T>[] sources = this.sources;
int count = 0;
count = sources.length;
//创建ZipCoordinator实例，传参：1、观察者Observer；2、传入的Function；3、Observable集合数量；4、是否推迟Error
ZipCoordinator<T, R> zc = new ZipCoordinator<T, R>(s, zipper, count, delayError);
zc.subscribe(sources, bufferSize); //调用subscribe（）
}
- ZipCoordinator.subscribe（）：为集合中每个Observable订阅观察者
public void subscribe(ObservableSource<? extends T>[] sources, int bufferSize) {
ZipObserver<T, R>[] s = observers; //创建观察者数组，长度为count
int len = s.length;
for (int i = 0; i < len; i++) {
s[i] = new ZipObserver<T, R>(this, bufferSize); //遍历创建ZipObserver
}
this.lazySet(0);
actual.onSubscribe(this); //响应观察者的onSubscribe（）
for (int i = 0; i < len; i++) {
sources[i].subscribe(s[i]); //遍历Observable集合依次订阅观察者
}
}
- ZipObserver：从上面我们知道，数组中的Observable都会发送事件到对应的ZipObserver中，在onNext（）中将发送的数据加入队列然后调用parent.drain()方法
ZipObserver(ZipCoordinator<T, R> parent, int bufferSize) {
this.parent = parent;
this.queue = new SpscLinkedArrayQueue<T>(bufferSize); //实例化一个队列，默认大小128
}
@Override
public void onNext(T t) { //响应事件的onNext（）
queue.offer(t);
parent.drain();
}
- 在drain（）方法中使用死循环不断查找发送的事件，直到同一组Observable的都接收到发送事件，然后调用设置的方法统一进行转换最后返送事件
public void drain() {
final ZipObserver<T, R>[] zs = observers;
final Observer<? super R> a = actual; // 下游传递的Observer
for (; ; ) { //两层死循环
for (;; ) {
int i = 0;
int emptyCount = 0;
for (ZipObserver<T, R> z : zs) {
if (os[i] = null) {
T v = z.queue.poll(); //从Observer的队列中获取事件
boolean empty = v == null;
if (!empty) { //如果获取的事件不为空，则复制os[i],否则emptyCount++
os[i] = v;
} else {
emptyCount++;
}
} else { ………. }
i++; //下标++
}
if (emptyCount != 0) { //如果取出数据不为空，则跳出循环，确保每个Observable都取到了值
break;
}
// 执行zipper中传入的压缩方法
v = ObjectHelper.requireNonNull(zipper.apply(os.clone()), "The zipper returned a null value");
a.onNext(v); //执行下游onNext（）
}
}
}
简述工作过程：（第一、第二个观察者用 first、second代替）
- 当first发送数据1时会存储到ZipObserver的队列中，此时os[0] = null,从first_observer的队列中取出1，赋值os[0]=1;
- 然后for循环继续执行，此时os[1]= null,会从second_observer缓存区中获取数据，如果为空则跳出内部死循环
- 由于外部循环存在方法会继续循环，内部在从os[0]开始，此时os[0] = 1,second此时也会发送数据4到队列中
- 继续执行此时os[1]=null,从second的队列中回去数据赋值os[1] = 4；
- 此时emptyCount = 0方法向下执行，调用设置的Function.apply()处理数据(关于Function（）这里采用了嵌套方法)
- 调用下游Obserber.onNext()传递事件
4.5、onErrorReturn（）
@Override
public void subscribeActual(Observer<? super T> t) {
source.subscribe(new OnErrorReturnObserver<T>(t, valueSupplier)); //创建OnErrorReturnObserver
}
//OnErrorReturnObserver
@Override
public void onError(Throwable t) { //在onError（）方法中触发
T v;
v = valueSupplier.apply(t); //（1）在拦截onError时调用设置的方法，生成要发送的数据
actual.onNext(v); //（2）发送新生成的数据
actual.onComplete();
}
最终创建ObservableOnErrorReturn和OnErrorReturnObserver，在拦截到error后发送特定的值
4.6、retryWhen：重试操作符
创建ObservableRetryWhen实例，在使用retryWhen时会传入一个返回新的Observable的功能方法，在ObservableRetryWhen内部首先调用方法获取创建的newObservable，并对newObservable订阅观内部察查者Inner.Observer，在外部订阅观察者时当发生异常回调onError（）时，调用newObservable发送事件，
- 如果发送next（）触发内部观察者onNext（），在onNext（）中重新调用外部观察者订阅，所有程序会重新try；
- 如果发送onError（）会直接回到外部Observer的onError（）结束程序；
4.7、compose（）:构成操作符
compose（）可以将一系列的相同的操作封装在一起使用，将功能封装在ObservableTransformer的实例中，在接口方法中可以对传入的Observable执行操作然后重新返回，系统会将重新返回的Observable封装在新的ObservableFromUnsafeSource中继续执行
- 创建ObservableTransformer实例对Observable执行统一的操作
public static <T> ObservableTransformer<T, T> rxSchedulerHelper() {
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply(Observable<T> upstream) { //对传入的Observable进行指定线程操作
return upstream.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
};
}
- 使用compose（）
Observable.just(1)
.compose(RxHelper.<Integer>rxSchedulerHelper())
.subscribe()
//效果等同于
Observable.just(1)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
- 源码分析
public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) {
return wrap(((ObservableTransformer<T, R>) composer.apply(this));
}
public static <T> Observable<T> wrap(ObservableSource<T> source) {
return RxJavaPlugins.onAssembly(new ObservableFromUnsafeSource<T>(source));
}
//ObservableFromUnsafeSource只是作为了一层中转站
public final class ObservableFromUnsafeSource<T> extends Observable<T> {
final ObservableSource<T> source;
public ObservableFromUnsafeSource(ObservableSource<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
source.subscribe(observer);
}
}
执行流程如下：
- compose（）首先执行apply（）传入this，this为当前的Observable，此处表示为Observable添加几个统一的操作符
- 使用ObservableFromUnsafeSource封装包裹source
- 在ObservableFromUnsafeSource.subscribeActual（）中触发source.subscribe(observer)完成订阅；
5、RxJava取消订阅
- RxJava取消订阅（ObservableOnCreate）
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer); //（1）创建
observer.onSubscribe(parent); //回调返回parent
}
由上面的分析知道，在ObservableOnCreate（）的subscribeActual（）会创建CreateEmitter对象封装Observer，并回调onSubscribe（）返回parent
- 调用CreateEmitter.dispose()取消订阅
@Override
public void dispose() {
DisposableHelper.dispose(this); //设置解除订阅标识位
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get()); //获取是否解除订阅
}
- 在每次发送事件之前都会判断是否解除订阅，如果设置了解除操作符就会停止事件发送
@Override
public void onNext(T t) {
if (!isDisposed()) {
observer.onNext(t);
}
}
到此RxJava的基本原理和常用的操作符就分析完了，RxJava的操作符之多功能之强大真的不是几句话能说完的，但了解其内部原理有利于更好的封装和使用它，除了本篇之外还有关于Schedule的部分也很重要会放在下一篇文章整理。