RxJava源码分析（一）：最简单的订阅流程

一、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));
    }

传的参数是：ObservableOnSubscribe，返回值是：Observable
ObservableOnSubscribe是一个接口，有一个实现方法subscribe(ObservableEmitter emitter)

public interface ObservableOnSubscribe<T> {
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

方法的参数是ObservableEmitter：

public interface ObservableEmitter<T> extends Emitter<T> {
    void setDisposable(@Nullable Disposable d);
    void setCancellable(@Nullable Cancellable c);
    boolean isDisposed();
    @NonNull
    ObservableEmitter<T> serialize();
    boolean tryOnError(@NonNull Throwable t);
}

ObservableEmitter也是一个接口，继承Emitter接口：

public interface Emitter<T> {
    void onNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

返回之前create()方法的返回值：RxJavaPlugins.onAssembly(new ObservableCreate(source))，其中，RxJavaPlugins.onAssembly()方法：

    @SuppressWarnings({ "rawtypes", "unchecked" })
    @NonNull
    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;
    }

暂且不管，其返回值就是传入的参数：new ObservableCreate(source),ObservableCreate继承抽象类Observable

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

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

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}

由上分析可知：通过调用Observable的静态方法create()并传入参数ObservableOnSubscribe可以得到Observable对象，而在create()方法中是通过new ObservableCreate()得到的Observable对象，构造方法的形参就是create()方法传入的ObservableOnSubscribe对象。

至此，我们通过create()方法获取了Observable对象

二、Observable.subscribe()订阅

直接上源码：

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    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);
            // 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;
        }
    }

Observable对象调用subscribe(),传入的参数为Observer对象。其它的先不管，注意subscribe()中调用了一个方法：subscribeActual(observer)，这个方法在之前创建Observable对象时的ObservableCreate类中实现。

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

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

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}

这个方法中的核心操作主要有三个：

1、创建CreateEmitter对象，传入观察者Observer对象。CreateEmitter实现了Disposable和ObservableEmitter接口

CreateEmitter<T> parent = new CreateEmitter<T>(observer);

2、观察者调用onSubscribe()方法将上一步创建的CreateEmitter对象传入，onSubscribe()的形参是了Disposable

observer.onSubscribe(parent);

3、调用ObservableOnSubscribe的subscribe()方法，形参是ObservableEmitter。ObservableOnSubscribe对象是在第一步create()方法中传入的。

source.subscribe(parent);

之后还有一个错误处理操作

    Exceptions.throwIfFatal(ex);
    parent.onError(ex);

这里看一下CreateEmitter类：

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

        ...

        final Observer<? super T> observer;

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

        @Override
        public void onNext(T t) {
            //1、参数不能为null
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            //2、没有被dispose就会调用observer的onNext(t)
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            //3、如果已经dispose了就返回false,抛出异常，所以onComplete方法与onError方法互斥
            if (!tryOnError(t)) {
                RxJavaPlugins.onError(t);
            }
        }
        
        @Override
        public boolean tryOnError(Throwable t) {
            if (t == null) {
                t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
            }
            //1、没有被dispose就会调用observer的onError(t)
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    //2、调用完就会dispose()了
                    dispose();
                }
                return true;
            }
            return false;
        }
        
        @Override
        public void onComplete() {
            //1、没有被dispose就会调用observer的onCompletet()
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {     
                    //2、调用完就会dispose()了
                    dispose();
                }
            }
        }

        ...
    }

注意其中的onNext(),onError(),onComplete()三个方法，调用CreateEmitter类的这三个方法实际上调用的是Observer类对应的三个方法。

即，在ObservableOnSubscribe类的方法subscribe(ObservableEmitter emitter)中通过形参ObservableEmitter调用onNext(),onError(),onComplete()方法实际上调用的是Observer类对应的三个方法。

这样被观察者Observable与观察者Observer就实现了订阅关系。

总结：

1. Observable通过调用create()方法通过new ObservableCreate()返回Observable对象，传入ObservableOnSubscribe对象作为形参。
2. Observable对象调用subscribe()方法传入Observer对象实现订阅
3. 在ObservableCreate类的subscribeActual(Observer observer)方法中通过CreateEmitter关联起了ObservableOnSubscribe与Observer。
4. Observer的onComplete()和onError() 互斥只能执行一次，因为CreateEmitter在回调他们两中任意一个后，都会自动dispose()。