从RxJava2源码看其工作流程

源码还是要多看看的。
毕竟看源码与写代码的关系，就和多读书与写作文的关系一样。

书读得多了
…
就会忘了

所以还是记下来最好。

先有一段普通的实现：

        Observable.just(1,23,4).map(new Function<Integer, String>() {
		    @Override
		    public String apply(Integer integer) throws Exception {
			    return integer.toString();
		    }
	    }).subscribe(new Observer<String>() {
		    @Override
		    public void onSubscribe(Disposable d) {
                System.out.println(d.getClass());
		    }

		    @Override
		    public void onNext(String s) {
                System.out.println(s);
		    }

		    @Override
		    public void onError(Throwable e) {

		    }

		    @Override
		    public void onComplete() {
                System.out.println("complete");
		    }
	    });

这就是最常见的写法之一，这其中just用于创建被观察者，map用于转换数据源，subscribe用于订阅观察者。

那么先不管什么观察者不观察者的，也不管其他各种花里胡哨的用法，先把这十几行代码运行的流程捋顺咯。

Observable的创建

首先看这个just是怎么创建Observable的：

//Observable.java
    public static <T> Observable<T> just(T item1, T item2, T item3) {
        ObjectHelper.requireNonNull(item1, "item1 is null");
        ObjectHelper.requireNonNull(item2, "item2 is null");
        ObjectHelper.requireNonNull(item3, "item3 is null");

        return fromArray(item1, item2, item3);
    }

    public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) {
            return empty();
        }
        if (items.length == 1) {
            return just(items[0]);
        }
        return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
    }

可以看到，just实际上是通过fromArray进行创建的，而fromArray又是统一通过RxJavaPlugins.onAssembly方法创建的。
或者说，所有Observable的创建都是RxJavaPlugins.onAssembly方法创建的，只是传入参数有所不同。
比如最普通的create创建方式：

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

和fromArray的区别仅在于传入的参数一个为ObservableFromArray，一个为ObservableCreate。
assembly有“装配、组件”的意思：

//RxJavaPlugins.java
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

其中Function在无特殊情况下，一般均为null，所以传进来的是什么，就会返回什么。也就是说just返回的Observable其实就是一个ObservableFromArray，这东西也是继承了Observable的一个类。

Observable的变换

在实际使用中会频繁使用到map、debounce、concat之类的操作符，这些操作符的作用从表面上看就是“将一种Observable数据转换为另一种Observable数据”：

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

而实际上这种转换操作与创建用的是同一个方法，不过传入的参数类又变为ObservableMap，并且带入了mapper也就是转换函数，以及调用这种变换方法的Observable；
其他如debounce之类的操作符也是类似：

//Observable.java
    public final <U> Observable<T> debounce(Function<? super T, ? extends ObservableSource<U>> debounceSelector) {
        ObjectHelper.requireNonNull(debounceSelector, "debounceSelector is null");
        return RxJavaPlugins.onAssembly(new ObservableDebounce<T, U>(this, debounceSelector));
    }

同样是创建了一个新的类ObservableDebounce，这个新的类拥有其功能函数。

Observable的订阅

经历过创建、变换，最后来到订阅。在RxJava2中，是使用subscribe方法：

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

            ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            RxJavaPlugins.onError(e);
            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

抛开异常处理不说，这里有两个方法真正起到了作用：

observer = RxJavaPlugins.onSubscribe(this, observer);
subscribeActual(observer);

先看onSubscribe方法：

//RxJavaPlugins.java
    public static <T> Observer<? super T> onSubscribe(@NonNull Observable<T> source, @NonNull Observer<? super T> observer) {
        BiFunction<? super Observable, ? super Observer, ? extends Observer> f = onObservableSubscribe;
        if (f != null) {
            return apply(f, source, observer);
        }
        return observer;
    }

这里的Observer和之前创建Observable的时候相似，function一般都为null，所以传入什么Observer就返回什么Observer。这里是用匿名的方式创建的一个Observer，未经变化。
再看subscribeActual方法：

//Observable.java
    protected abstract void subscribeActual(Observer<? super T> observer);

这是个抽象方法。
可以肯定在之前出现的ObservableFromArray、ObservableMap中都有实现。
而在最开始的示例代码中，ObservableFromArray被转换成了ObservableMap，所以这里实际调用的是ObservableMap类的subscribeActual方法：

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;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

而ObservableMap实现的subscribeActual方法又调用了传入的ObservableFromArray的subscribe方法…
这意味着ObservableMap的订阅其实就是把传入的ObservableFromArray与自己创建的一个MapObserver绑定在了一起，也就是为ObservableFromArray和MapObserver创建了订阅关系。
那么ObservableFromArray也需要重走ObservableMap的老路，最后来到他自己实现的subscribeActual方法：

//ObservableFromArray.java
public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }

    @Override
    public void subscribeActual(Observer<? super T> observer) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(observer, array);

        observer.onSubscribe(d);

        if (d.fusionMode) {
            return;
        }

        d.run();
    }
}

这里有两个可疑操作， 一个是observer的onSubscribe方法， 这个方法肯定在一些Observer中有实现，另一个是run。

从上文可知，ObservableFromArray的subscribeActual方法传入的Observer是MapObserver，而在这里MapObserver和最开始传入的数组数据一起被封装为一个FromArrayDisposable，并且这个FromArrayDisposable有一个类似于Runnable的run方法，似乎可以自行启动。

先看这个onSubscribe方法：

    public final void onSubscribe(Disposable d) {
        if (DisposableHelper.validate(this.upstream, d)) {
            this.upstream = d;
            if (d instanceof QueueDisposable) {
                this.qd = (QueueDisposable<T>)d;
            }

            if (beforeDownstream()) {
                downstream.onSubscribe(this);
                afterDownstream();
            }
        }
    }

主要是为了调用传入的Observer的onSubscribe方法，一般没有实现，可以先忽略。

再看FromArrayDisposable，这个类是ObservableFromArray的静态内部类：

//省略部分方法
    static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {

        final Observer<? super T> downstream;

        final T[] array;

        volatile boolean disposed;
        
        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.downstream = actual;
            this.array = array;
        }
        
        @Override
        public boolean isDisposed() {
            return disposed;
        }

        void run() {
            T[] a = array;
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                if (value == null) {
                    downstream.onError(new NullPointerException("The element at index " + i + " is null"));
                    return;
                }
                downstream.onNext(value);
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }
    }

这里我们看到了onNext的出现，而这个downstream其实就是传入的Observer。
也就是说，当ObservableFromArray调用subscribe时订阅MapObserver时，MapObserver就开始调用onNext方法。

再看这个MapObserver，这个MapObserver毫无疑问也传入了我们最开始写的那个匿名的Observer，MapObserver类是ObservableMap的一个内部类：

    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;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

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

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

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

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

在MapObserver中又看到了downstream的身影，而这个downstream又是传入的匿名Observer，可以在MapObserver的父类BasicFuseableObserver中看到：

public abstract class BasicFuseableObserver<T, R> implements Observer<T>, QueueDisposable<R> {

    /** The downstream subscriber. */
    protected final Observer<? super R> downstream;

    public BasicFuseableObserver(Observer<? super R> downstream) {
        this.downstream = downstream;
    }
	
	//省略其他代码
}

所以总结起来，这样的订阅就像两个代理一样，ObservableMap代理了ObservableFromArray，MapObserver代理了本来的匿名Observer，然后在subcribe时，两个代理建立了真正的联系。

假如把之前示例代码中的匿名Observer叫做AnonymousObserver的话，整个工作流程就可以用图来表示一下：