RxJava-洋葱模式，源码分析

源码：io.reactivex.rxjava2:rxjava:2.0.7
执行主线注释标识：// ####
省略代码标识 // …
PS：不定期更新内容

场景1：RxJava的包裹模式
RxJava用到了洋葱模式，通过抽象层一连串的类封装实现链式调用，并且统一实现层调用风格的实现，最后通过反向一层层调用回到最初执行方法，在一层层向下执行。

// #### 关键方法create进去看看  1->A
Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
               // #### 这里的方法onNext，也就是第一层包裹ObservableCreate里面内部类ObservableEmitter的方法onNext 进去看看1->F
                e.onNext("Goon");
                e.onComplete();
            }
        })
        // #### 关键方法map进去看看 1->B
        .map(new Function<String, Integer>() {
            // #### 1->G
            @Override
            public Integer apply(String s) throws Exception {
                return 1234;
            }
        })
        // #### 关键方法map进去看看 1->C
        .map(new Function<Integer, Boolean>() {
            // #### 上层流程1->G调用完apply后会自动执行下一层的onNext就到这个流程，最后调用onNext 结束1->H
            @Override
            public Boolean apply(Integer integer) throws Exception {
                return true;
            }
        })
        // #### 关键方法subscribe调用的是最外层包裹也就是流程1-A的ObservableCreate 1->D
        .subscribe(new Observer<Boolean>() {
            // #### 1->E
            @Override
            public void onSubscribe(Disposable d) { }
            // #### 执行完1->H流程后触发 最后方法onNext，结束1->I
            @Override
            public void onNext(Boolean bool) {
                Log.d(Flag.TAG, "onNext bool:" + bool);
            }

            @Override
            public void onError(Throwable e) { }

            @Override
            public void onComplete() { }
        });

Observable.java
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        // #### 关键类RxJavaPlugins是RxJava的执行流程hock，后面代码分析经常出现，最后分析1->A->A
        // #### 这里返回的是Observable，所以可以链式调用1->B的map方法，关键类ObservableCreate，现在现在被包裹了一层ObservableCreate() 结束1->A
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        // #### 经过1->A流程，现在被包裹了一层 ObservableCreate().ObservableMap，继续链式调用1->C流程。 结束1->B
        // #### 1->B链式调用方法与1->C一致，现在被包裹了一层 ObservableCreate().ObservableMap().ObservableMap，继续链式调用1->D流程。 结束1->C
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
            // #### 这里执行的是抽象方法subscribeActual，就是实现Observable类的ObservableMap的subscribeActual 1->D
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

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

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    // #### 1->D流程最终会执行到这个方法
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        // #### 1->D流程会触发onSubscribe方法回调就是1->E流程
        observer.onSubscribe(parent);

        try {
            // #### 1->D流程最终会执行到这个方法subscribe，结束1->D
            // #### 这里会粗发执行流程1->F
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

    static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {


        private static final long serialVersionUID = -3434801548987643227L;

        final Observer<? super T> observer;

        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            // #### isDisposed是判断是否取消执行，这里涉及到RxJava的内存泄露问题，页面或者UI生命周期结束时需要移除相关绑定
            if (!isDisposed()) {
                // #### 这里会触发包裹第二个包裹ObservableMap的内部类的onNext方法然后触发apply方法，也就是流程1->G. 1->F
                observer.onNext(t);
            }
        }
    }
  }

ObservableMap.java
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
    // #### 1->D
    @Override
    public void subscribeActual(Observer<? super U> t) {
         // #### 这里的subscribe会执行到第一个ObservableMap的subscribeActual 结束，如此类推一直执行到第一个的Observable子类也就是ObservableCreate的subscribeActual 1->D
        source.subscribe(new MapObserver<T, U>(t, function));
    }


    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }
        // ####  1->F
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                actual.onNext(null);
                return;
            }

            U v;

            try {
                 // ####  关键方法mapper.apply(t)，1->F
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
             // ####  执行链式下一个包裹的onNext，结束1->F
            actual.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qs.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}