RxJava2.0 全异步编程 源码解析

1 常用操作的实例

Single<Model> xm = Single.create((SingleOnSubscribe<Model>) emitter -> { System.out.println("do some future task"); emitter.onSuccess(new Model("小明", 6)); }); Single<Model> xh = Single.create((SingleOnSubscribe<Model>) emitter -> { System.out.println("do some future task"); emitter.onSuccess(new Model("小红", 6)); }); Single<Model> xhMap = xh.map(it -> new Model(it.name + "map小红袄", it.age + 1) ); Single<Model> xhFlatMap = xh.flatMap(it -> Single.create((SingleOnSubscribe<Model>) emitter -> { emitter.onSuccess(new Model(it.name + "flatMap大红", 16)); })); Single<List<Model>> zip = Single.zip(xm, xhMap, xhFlatMap, (s1, s2, s3) -> Lists.newArrayList(s1, s2, s3)); SingleObserver<List<Model>> xwObserver = new SingleObserver<List<Model>>() { @Override public void onSubscribe(Disposable d) { } @Override public void onSuccess(List<Model> models) { System.out.println(models.toString()); } @Override public void onError(Throwable e) { } }; zip.subscribe(xwObserver);

上面的代码有几个主要的操作。

1. 通过 Single 的 create操作创建 Single 对象，创建了 xm,  xh  Single对象；
2. 通过 Single 的 map 操作 xh 转换成了 xhMap 对象；
3. 通过 Single 的 flatMap 操作 xh 转换成成了 xhFlatMap 对象；
4. 通过 Single 的 zip 操作， 把 xm, xhMap, xhFlatMap 对象 转换成了 zip 对象;
5. zip 对象 被 xwObserver subscribe();

通过这个实例我们来分析 三个过程，1. 调用链的创建过程，2. 观察者的订阅过程，3. 任务链的执行过程

2 调用链的创建过程

首先我们根据 Single.create() 的源码，看到如下

public static <T> Single<T> create(SingleOnSubscribe<T> source) { ObjectHelper.requireNonNull(source, "source is null"); return RxJavaPlugins.onAssembly(new SingleCreate<T>(source)); }

其中 RxJavaPlugins.onAssembly() 操作为 hook function 的功能，所以 create 操作就是创建了  SingleCreate 实例。入参为 SingleOnSubscribe 实例，就是订阅的内容。

接下来我们看下 Single 对象的 map 操作

public final <R> Single<R> map(Function<? super T, ? extends R> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaPlugins.onAssembly(new SingleMap<T, R>(this, mapper)); }

Single对象 map 操作创建了一个新的SingleMap 实例，实例中有两个成员，一个是 Single 对象本身作为 source 成员，另外一个就是 mapper Function 接口函数。

flatMap 操作和 zip 操作类似。flatMap 创建了 SingleFlatMap 实例， zip 操作创建了 SingleZipArray  实例。

下面是订阅过程，观察者 xwObserver 订阅了 被观察者 zip Single 对象。subscribe() 源码如下

public final void subscribe(SingleObserver<? super T> subscriber) { ObjectHelper.requireNonNull(subscriber, "subscriber is null"); subscriber = RxJavaPlugins.onSubscribe(this, subscriber); subscribeActual(subscriber); }

subscribe() 发现里面没有太多实现，调用了 抽象方法subscribeActual(), 所以这个方法才是由子类实现的真实订阅过程。后面我们讲一下具体的订阅过程

实例对象之间的 类图

 

调用链路

 

 

2 订阅过程，观察者模式

订阅过程和调用链的创建过程相反，从最后一个 观察者 xwObserver  开始逐级向上subscribe()。通过上面的分析我们知道，订阅的具体实现在每个子类的subscribeActual()中。

我们取 小红袄这条线路来讲一下逆向订阅的过程。

 

首先 xwObserver 订阅了 SingZipArray 对象， 分析 SingZipArray 的subscribeActual() 方法

protected void subscribeActual(SingleObserver<? super R> observer) { SingleSource<? extends T>[] sources = this.sources; int n = sources.length; if (n == 1) { sources[0].subscribe(new SingleMap.MapSingleObserver<T, R>(observer, new SingletonArrayFunc())); return; } ZipCoordinator<T, R> parent = new ZipCoordinator<T, R>(observer, n, zipper); observer.onSubscribe(parent); for (int i = 0; i < n; i++) { if (parent.isDisposed()) { return; } SingleSource<? extends T> source = sources[i]; if (source == null) { parent.innerError(new NullPointerException("One of the sources is null"), i); return; } source.subscribe(parent.observers[i]); } }

observer 作为观察者，生成了 被观察者 ZipCoordinator。 当ZipCoordinator 发生变化时会通知  observer.

同时 ZipCoordinator 作为一个观察者 又同时订阅了 每个 source 的 ZipSingleObserver，此时 ZipSingleObserver 是作为被观察者，当任何一个 source 有变化时都会通知 ZipCoordinator

ZipSingleObserver  作为观察者，又订阅了 SingleMap 对象，SingleMap 生成了 被观察者  MapSingleObserver 对象。当MapSingleObserver 有 变化时，会通知 ZipSingleObserver 对象。

MapSingleObserver 作为观察者，又订阅了 SingleCreate 对象。SingleCreate 对象的subscribeActual（）源码如下：

public final class SingleCreate<T> extends Single<T> { final SingleOnSubscribe<T> source; public SingleCreate(SingleOnSubscribe<T> source) { this.source = source; } @Override protected void subscribeActual(SingleObserver<? super T> s) { Emitter<T> parent = new Emitter<T>(s); s.onSubscribe(parent); try { source.subscribe(parent); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); parent.onError(ex); } }」

SingleCreate 对象生成了  Emitter，这个可以理解为 事件反射器，Emitter 对象 订阅的 SingleOnSubscribe， 就是单一的 Single 主题，这里一般就是我们需要进行的一些 比较耗时的 io、网络等操作。

整个订阅的过程就是这样，可以看到是逐步向上订阅，Observer 即是观察者也是被观察者。

 

3. 执行过程

通过上面订阅链的分析得知，emitter 订阅了 SingleOnSubscribe， SingleOnSubscribe作为被观察者，它的接口subscribe() 会执行 一些 work, 并订阅者 emitter。

Emitter 会调用自己的 onSuccess 方法 然后通知 自己的观察者actual 对象 也就是 MapSingleObserver. 依次通知调用，执行过程如下