RxJava2 源码分析

前言

很多项目使用流行的Rxjava2 + Retrofit搭建网络框架，Rxjava现在已经发展到Rxjava2，之前一直都只是再用Rxjava，但从来没有了解下Rxjava的内部实现，接下来一步步来分析Rxjava2的源码，Rxjava2分Observable和Flowable两种（无被压和有被压），我们今天先从简单的无背压的observable来分析。源码基于rxjava:2.1.1。

简单的例子

先来段最简单的代码，直观的了解下整个Rxjava运行的完整流程。

 1 private void doSomeWork() {
 2         Observable<String> observable =  Observable.create(new ObservableOnSubscribe<String>() {
 3             @Override
 4             public void subscribe(ObservableEmitter<String> e) throws Exception {
 5                 e.onNext("a");
 6                 e.onComplete();
 7             }
 8         });
 9         Observer observer = new Observer<String>() {
10 
11             @Override
12             public void onSubscribe(Disposable d) {
13                 Log.i("lx", " onSubscribe : " + d.isDisposed());
14             }
15 
16             @Override
17             public void onNext(String str) {
18                 Log.i("lx", " onNext : " + str);
19             }
20 
21             @Override
22             public void onError(Throwable e) {
23                 Log.i("lx", " onError : " + e.getMessage());
24             }
25 
26             @Override
27             public void onComplete() {
28                 Log.i("lx", " onComplete");
29             }
30         };
31         observable.subscribe(observer);
32     }

上面代码之所以将observable和observer单独声明，最后再调用observable.subscribe(observer);
是为了分步来分析：

被观察者 Observable 如何生产事件的
被观察者 Observable 何时生产事件的
观察者Observer是何时接收到上游事件的
Observable 与Observer是如何关联在一起的

Observable

Observable是数据的上游，即事件生产者
首先来分析事件是如何生成的，直接看代码 Observable.create()方法。

1 @SchedulerSupport(SchedulerSupport.NONE)
2     public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {    // ObservableOnSubscribe 是个接口，只包含subscribe方法，是事件生产的源头。
3         ObjectHelper.requireNonNull(source, "source is null"); // 判空
4         return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
5     }

最重要的是RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));这句代码。继续跟踪进去

 1 /**
 2      * Calls the associated hook function.
 3      * @param <T> the value type
 4      * @param source the hook's input value
 5      * @return the value returned by the hook
 6      */
 7     @SuppressWarnings({ "rawtypes", "unchecked" })
 8     @NonNull
 9     public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
10         Function<? super Observable, ? extends Observable> f = onObservableAssembly;
11         if (f != null) {
12             return apply(f, source);
13         }
14         return source;
15     }

看注释，原来这个方法是个hook function。通过调试得知静态对象onObservableAssembly默认为null，所以此方法直接返回传入的参数source。
onObservableAssembly可以通过静态方法RxJavaPlugins. setOnObservableAssembly ()设置全局的Hook函数，有兴趣的同学可以自己去试试。这里暂且不谈，我们继续返回代码。
现在我们明白了:

1  Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
2 　　...
3 　　...
4 })

相当于：

1 Observable<String> observable=new ObservableCreate(new ObservableOnSubscribe<String>() {
2 　　...
3 　　...
4 }))

好了，至此我们明白了，事件的源就是new ObservableCreate()对象，将ObservableOnSubscribe作为参数传递给ObservableCreate的构造函数。
事件是由接口ObservableOnSubscribe的subscribe方法上产的，至于何时生产事件，稍后再分析。

Observer

Observer 是数据的下游，即事件消费者
Observer是个interface，包含：

1     void onSubscribe(@NonNull Disposable d);
2     void onNext(@NonNull T t);
3     void onError(@NonNull Throwable e);
4     void onComplete();

上游发送的事件就是再这几个方法中被消费的。上游何时发送事件、如何发送，稍后再表。

重点来了，接下来最重要的方法来了：observable.subscribe(observer);
从这个方法的名字就知道，subscribe是订阅，是将观察者(observer)与被观察者(observable)连接起来的方法。只有subscribe方法执行后，上游产生的事件才能被下游接收并处理。其实自然的方式应该是observer订阅(subscribe) observable, 但这样会打断rxjava的链式结构。所以采用相反的方式。
接下来看源码，只列出关键代码

 1 public final void subscribe(Observer<? super T> observer) {
 2         ObjectHelper.requireNonNull(observer, "observer is null");
 3         ......
 4        observer = RxJavaPlugins.onSubscribe(this, observer); // hook ，默认直接返回observer
 5        ......
 6        subscribeActual(observer);  // 这个才是真正实现订阅的方法。
 7        ......
 8     }
 9 
10 // subscribeActual 是抽象方法，所以需要到实现类中去看具体实现，也就是说实现是在上文中提到的ObservableCreate中
11 protected abstract void subscribeActual(Observer<? super T> observer);

接下来我们来看ObservableCreate.java：

 1 public ObservableCreate(ObservableOnSubscribe<T> source) {
 2         this.source = source;  // 事件源，生产事件的接口，由我们自己实现
 3     }
 4 
 5    @Override
 6     protected void subscribeActual(Observer<? super T> observer) {
 7         CreateEmitter<T> parent = new CreateEmitter<T>(observer); // 发射器
 8         observer.onSubscribe(parent);  //直接回调了观察者的onSubscribe
 9 
10         try {
11             // 调用了事件源subscribe方法生产事件，同时将发射器传给事件源。 
12             // 现在我们明白了，数据源生产事件的subscribe方法只有在observable.subscribe(observer)被执行
13               后才执行的。 换言之，事件流是在订阅后才产生的。
14             //而observable被创建出来时并不生产事件，同时也不发射事件。
15           source.subscribe(parent);  
16         } catch (Throwable ex) {
17             Exceptions.throwIfFatal(ex);
18             parent.onError(ex);
19         }
20     }

现在我们明白了，数据源生产事件的subscribe方法只有在observable.subscribe(observer)被执行后才执行的。换言之，事件流是在订阅后才产生的。而observable被创建出来时并不生产事件，同时也不发射事件。
接下来我们再来看看事件是如何被发射出去，同时observer是如何接收到发射的事件的
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
CreateEmitter 实现了ObservableEmitter接口，同时ObservableEmitter接口又继承了Emitter接口。
CreateEmitter 还实现了Disposable接口，这个disposable接口是用来判断是否中断事件发射的。
从名称上就能看出，这个是发射器，故名思议是用来发射事件的，正是它将上游产生的事件发射到下游的。
Emitter是事件源与下游的桥梁。
CreateEmitter 主要包括方法：

1 void onNext(@NonNull T value);
2     void onError(@NonNull Throwable error);
3     void onComplete();
4     public void dispose() ;
5     public boolean isDisposed();

是不是跟observer的方法很像？
我们来看看CreateEmitter中这几个方法的具体实现：
只列出关键代码

 1 public void onNext(T t) {
 2          if (!isDisposed()) { // 判断事件是否需要被丢弃
 3              observer.onNext(t); // 调用Emitter的onNext，它会直接调用observer的onNext
 4          }
 5       }
 6       public void onError(Throwable t) {
 7            if (!isDisposed()) {
 8                 try {
 9                     observer.onError(t); // 调用Emitter的onError，它会直接调用observer的onError
10                 } finally {
11                     dispose();  // 当onError被触发时，执行dispose(), 后续onNext，onError， onComplete就不会继
12                                     续发射事件了
13                 }
14             }
15         }
16 
17        @Override
18         public void onComplete() {
19             if (!isDisposed()) {
20                 try {
21                     observer.onComplete(); // 调用Emitter的onComplete，它会直接调用observer的onComplete
22                 } finally {
23                     dispose();  // 当onComplete被触发时，也会执行dispose(), 后续onNext，onError， onComplete
24                                       同样不会继续发射事件了
25                 }
26             }
27         }

CreateEmitter 的onError和onComplete方法任何一个执行完都会执行dispose()中断事件发射，所以observer中的onError和onComplete也只能有一个被执行。
现在终于明白了，事件是如何被发射给下游的。当订阅成功后，数据源ObservableOnSubscribe开始生产事件，调用Emitter的onNext，onComplete向下游发射事件，

Emitter包含了observer的引用，又调用了observer onNext，onComplete，这样下游observer就接收到了上游发射的数据。

总结

Rxjava的流程大概是：

Observable.create 创建事件源，但并不生产也不发射事件。
实现observer接口，但此时没有也无法接受到任何发射来的事件。
订阅 observable.subscribe(observer)，此时会调用具体Observable的实现类中的subscribeActual方法，
此时会才会真正触发事件源生产事件，事件源生产出来的事件通过Emitter的onNext，onError，onComplete发射给observer对应的方法由下游observer消费掉。从而完成整个事件流的处理。

observer中的onSubscribe在订阅时即被调用，并传回了Disposable， observer中可以利用Disposable来随时中断事件流的发射。

今天所列举的例子是最简单的一个事件处理流程，没有使用线程调度，Rxjava最强大的就是异步时对线程的调度和随时切换观察者线程，未完待续。

前言

简单的例子

Observable

Observer

subscribe

总结

猜你喜欢