RxJava原理分析

RxJava 的核心思想的理解？

​ 有一个起点和一个终点，从起点开始把我们的“事件”流向终点，只不过在流的过程中可以增加拦截，对“事件”进行改变，终点只关心它的上一个流程。

RxJava的核心：订阅流程、线程切换。

源码基于 io.reactivex.rxjava2:rxjava:2.1.12;

首先看下正常的 RxJava 使用方法：

    Observable.create(new ObservableOnSubscribe<String>() {
   
   
        @Override
        public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
   
   
            emitter.onNext("A");
        }
    }).subscribe(new Observer<String>() {
   
   
        @Override
        public void onSubscribe(@NonNull Disposable d) {
   
   

        }

        @Override
        public void onNext(@NonNull String s) {
   
   
						// 这里可以收到 A
        }

        @Override
        public void onError(@NonNull Throwable e) {
   
   

        }

        @Override
        public void onComplete() {
   
   

        }
    });

然后我们先后从 Observer（订阅者，观察者），Observable（发布者，被观察者），subscribe（订阅）来看下具体的流程。

订阅流程

1. Observer 源码

public interface Observer<T> {
   
   

    /**
     * 为观察者提供以同步方式（从onNext(Object) ）和异步方式取消（处置）与Observable的连接（通道）的方法。
     *
     * 参数：d –可随时调用其Disposable.dispose()的Disposable实例以取消连接
     * 自从：2.0
     */
    void onSubscribe(@NonNull Disposable d);

    /**
     * 为观察者提供一个新的观察对象。
     * Observable可以多次调用此方法。
     * Observable调用onComplete或onError之后，将不会再次调用此方法。
     *
     * 参数：t –可观察对象发射的项目
     */
    void onNext(@NonNull T t);

    /**
     * 通知观察者Observable发生错误情况。
     * 如果Observable调用此方法，则此后将不再调用onNext或onComplete 。
     */
    void onError(@NonNull Throwable e);

    /**
     * 通知观察者Observable已完成基于推送的通知的发送。
     * 如果Observable调用onError则它将不会调用此方法。
     */
    void onComplete();

}

2. Observable 创建过程

首先看下 Observable.create 的代码：

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
   
   
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

在 ObservableCreate 中只是把自定义的 source 赋了个值，保存了一下：

public final class ObservableCreate<T> extends Observable<T> {
   
   
    final ObservableOnSubscribe<T> source;

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

在 RxJavaPlugins.onAssembly 中什么都没做，很多操作符都会经过 onAssemly 的全局监听。传入什么就返回什么：

    /**
     * 调用关联的钩子函数。
     *
     * 参数：来源–挂钩的输入值
     * 类型参数：<T> –值类型
     * 返回值：钩子返回的值
     */
    @SuppressWarnings({
   
    "rawtypes", "unchecked" })
    @NonNull
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
   
   
      	// f 默认都是 null
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
   
   
            return apply(f, source);
        }
      	// 直接返回
        return source;
    }

3. subscribe 订阅过程

首先看下订阅的代码：

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
   
   
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
   
   
          	// 同上面 RxJavaPlugins.onAssembly 一样 原样返回
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
						// 会跳到 ObservableCreate 的subscribeActual方法
            subscribeActual(observer);
        } catch (NullPointerException e) {
   
    // NOPMD
            throw e;
        } catch (Throwable e) {
   
   
           // 这里省略不相关的代码
            throw npe;
        }
    }

在 ObservableCreate 中 subscribeActual 的代码如下：

    @Override
    protected void subscribeActual(Observer