Rxjava 2.1 订阅流程源码解析

一、前提说明

本文是在 Rxjava 2.1 的基础上进行的，目前只对 Rxjava 进行解析，未搭配 Retrofit 食用，如果想看 Rxjava + Retrofit 源码解析，请移步 Retrofit 2.1 + Rxjava 源码解析（一）。

二、Rxjava 使用栗子

Observable.create(new ObservableOnSubscribe() {
          @Override
          public void subscribe(ObservableEmitter emitter) throws Exception {
              Log.e("TAG", "第二被调用，发射事件，subscribe():  ");
              //发射器
              emitter.onNext("1");
              emitter.onNext("2");
              emitter.onNext("3");
              emitter.onComplete();
          }
      }).subscribe(new Observer() {
          @Override
          public void onSubscribe(Disposable d) {
              Log.e("TAG", "最先被调用，onSubscribe():  ");
          }

          @Override
          public void onNext(String s) {
              Log.e("TAG", "onNext():  " + s);
          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {
              Log.e("TAG", "onComplete():  ");
          }
      });

在这里我们可以看到首先创建了一个 Observable 对象，然后调用订阅方法 subscribe() 就可以完成观察者模式的订阅。

三、Observable 和 ObservableOnSubscribe

Observable 是一个抽象类， ObservableOnSubscribe 是接口，我们看看它们里面有哪些方法：

public interface ObservableOnSubscribe {

    /**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter e) throws Exception;
}

Observable 的接口方法就是我们常用的 api，如 subscribe()，combineLatest()，interval() 等等。

我们先看看 Observable.create(ObservableOnSubscribe) 里面做了什么：

public static  Observable create(ObservableOnSubscribe source) {
    //过滤掉无关紧要的代码
    return new ObservableCreate(source);
}

可以看到构造了 ObservableCreate 类的一个对象，猜测这个对象必然是 Observable 的子类，必然继承了 Observable 类。

public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }
    
    ......
}

好了，这里可以看到创建了一个 ObservableCreate 对象，它包含一个 ObservableOnSubscribe 对象。

四、subscribe()

我们从 ObservableCreate 累中没有看到 subscribe()，这么说肯定是在 Observable 类中：

public abstract class Observable implements ObservableSource {

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer observer) {
        
        //过滤掉无关紧要的代码
        subscribeActual(observer);      
    }
    
    protected abstract void subscribeActual(Observer observer);
    
    ......
}

我们回到 ObservableCreate 类中，查看 subscribeActual() ：

public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer observer) {
        //创建一个发射器
        CreateEmitter parent = new CreateEmitter(observer);
        //这里可以看到一旦订阅后，首先回调的方法是 observer#onSubscribe（）
        //可以在这个方法中做一些预处理
        observer.onSubscribe(parent);
        
        try {
            //接着会调用 ObservableOnSubscribe#subscribe()
            //这样就可以用发射器发送事件了
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            //发送 Error 事件
            parent.onError(ex);
        }
    }
    
    static final class CreateEmitter extends AtomicReference
    implements ObservableEmitter, Disposable {

        private static final long serialVersionUID = -3434801548987643227L;

        final Observer observer;

        CreateEmitter(Observer observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public boolean tryOnError(Throwable t) {
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
                return true;
            }
            return false;
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }
        
        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }
   }
   
    ......
}

从源码中可以看到，一旦调用了 Observable.subscribe(Observer)，首先会调用 observer.onSubscribe(disposable);，然后会调用 ObservableOnSubscribe.subscribe(observableEmitter)，之后在我们的栗子中会调用发射器的发送 Next 事件和 Complete 事件。

从发射器 CreateEmitter 的源码可以看到，调用 CreateEmitter.onNext(T t) 和 CreateEmitter.onComplete() 会调用 Observer.onNext(t) 和 Observer.onComplete()，这个就是观察者模式，被观察者状态发生变化，通知观察者。

五、订阅流程小结

基本订阅流程按照我们上面的梳理就很清晰了。我们首先创建了一个被观察者 Observable（具体来说是一个 ObservableCreate 对象），然后订阅观察者 Observer，这样就将 Observer 传进了 Observable 里面，当 Observable 的状态发生改变或者 Observable 发送事件的时候，就能唤起观察者进行响应了。