前言

接触RxJava也有将近2年了，虽然能够熟练使用，可是对里面的运行流程一直都是未知半解，虽然中间也有看过网上的博客，但总是看了又忘记。直到最近才下定决心，写一个关于RxJava2的系列专题，好好学习一下里面的源码流程，并以文章的形式记录下来（主要是防止自己过段时间又忘记了，谁叫我记性差呢，咳咳...）。希望我能坚持写完，由于水平有限，如有错误之处还请指正。

好了，话不多说，让我们先从一段代码开始

Observer<Integer> observer = new Observer<Integer>() {
    Disposable disposable;

    @Override
    public void onSubscribe(Disposable d) {
        Log.i(TAG, "onSubscribe:");
        disposable = d;
    }

    @Override
    public void onNext(Integer integer) {
        Log.i(TAG, "onNext: " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.i(TAG, "onError: " + e.getMessage());
        e.printStackTrace();
    }

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

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(observer);

以上便是RxJava的教学课程中一开始就教大家写的代码（嗯，我个人认为是这样的。）输出结果如下：

image.png

可以看到，onSubscribe是最先被调用的；其次依次执行onNext发送数1，2，3；最后执行onComplete结束数据发送。
好了，代码执行完了，那它的运行流程是什么样子的呢？我们先从事件源开始，也就是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));
}

可以看到，create方法接收一个ObservableOnSubscribe<T>接口类型的参数

public interface ObservableOnSubscribe<T> {
    /**
     * Called for each Observer that subscribes.
     * @param emitter the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

该接口只有一个方法subscribe，咦？好像和文章一开始的代码最后面的subscribe方法一模一样啊，不过我们先不管这些，继续往下看，该方法接收一个ObservableEmitter<T>接口类型的参数：

public interface ObservableEmitter<T> extends Emitter<T> {
    void setDisposable(@Nullable Disposable d);

    void setCancellable(@Nullable Cancellable c);

    boolean isDisposed();

    @NonNull
    ObservableEmitter<T> serialize();

    @Experimental
    boolean tryOnError(@NonNull Throwable t);
}

ObservableEmitter继承自接口Emitter：

public interface Emitter<T> {
    void onNext(@NonNull T value);

    void onError(@NonNull Throwable error);

    void onComplete();
}

Emitter里面的三个方法还是蛮熟悉的，刚好和observer中的onNext，onComplete和onError一一对应，他们之间是怎么建立联系的呢？好像还漏了个onSubscribe，这个方法又是什么时候调用的呢？我们回过头来继续看Observable.create方法。

让我们再看一眼Observable.create方法：

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

上面说到该方法接收类型为ObservableOnSubscribe<T>接口的参数，然后将其传入到ObservableCreate<T>类的构造方法中，这个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;
}

根据这个方法的描述，它返回一个钩子（hook），也就是将接收的参数做了一下处理再将这个参数返回给调用者。RxjavaPlugins类的其他方法也是类似的处理过程。总之我们只要明白这个方法把传进去的参数最终又返回给了调用者就行了。

我们再回到Observable.create方法中，可以看到，create方法将传进去的ObservableOnSubscribe<T>又传递给了ObservableCreate<T>类的构造方法，最后通过RxJavaPlugins.onAssembly将这个构造方法生成的ObservableCreate对象返回给调用者，这个ObservableCreate也是继承自Observable类。于是一个具体的Observable对象就诞生了，其具体对象类型为ObservableCreate类，接下来我们就来介绍这个类：

在介绍ObservableCreate类之前，我们先来梳理下思路：

1、Observable.create方法生成一个Observable对象，也就是被观察者
2、该方法需要接收一个ObservableOnSubscribe<T>类型的参数
3、将接收到的ObservableOnSubscribe<T>类型的参数传递到ObservableCreate<T>类的构造方法中，生成ObservableCreate对象，并通过RxJavaPlugins.onAssembly方法这个对象返回。
这样，一个具体的被观察者对象就诞生了，他就是ObservableCreate对象。

看样子我们的事件订阅就是在这个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);
        }
    }

    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) {
            //......代码省略
        }
        //......代码省略
    }
    //......代码省略
}

我们看到该类有个source成员变量，类型是ObservableOnSubscribe<T>，正是Observable.create方法传入的参数。我们重点来看subscribeActual(Observer<? super T> observer)这个方法：

subscribeActual方法分析

• 1、subscribeActual接收一个Observer类型的参数（观察者），看样子好像是我们在订阅的时候传入的observer，到底是不是我们后面再看
• 2、将传入的observer参数包装成一个CreateEmitter。
• 3、observer调用自己的onSubscribe方法，这个方法的参数正式上面包装observer的CreateEmitter。
• 4、source.subscribe(parent)真正的订阅发生的地方。这个source就是Observable.create方法中传入的 ObservableOnSubscribe对象，parent则是步骤2中包装observer的CreateEmitter。

因此这里执行的subscribe方法正是Observable.create方法中所传入ObservableOnSubscribe接口里面的subscribe方法。这样一来我们就明白了在文章开始的代码中，subscribe方法中我们调用emitter.onNext，emitter.onComplete，这个emitter实际上就是步骤2中包装observer后生成的CreateEmitter对象，CreateEmitter类实现了ObservableEmitter接口。

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(observer);

• 5、这里在source.subscribe(parent)中进行了异常捕获，如果subscribe抛出了异常，则调用parent.onError(ex);

这样看来，我们的观察者observer和CreateEmitter之间有着很大的联系，我们来分析下CreateEmitter这个类：

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 (!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();
            }
        }
    }
    //......代码省略
}

从上面代码中我们看到，这个类继承自ActimicReference，这样它便是原子级的，同时实现了ObservableEmitter<T>和Disposable接口（关于Disposable我们在下一章讨论），而ObservableEmitter又继承自Emitter接口。因此我们重点看CreateEmitter所实现的Emitter中的三个方法，即分别是onNext，onComplete和OnError。首先我们看它的onNext方法

@Override
public void onNext(T t) {
    //......代码省略
    if (!isDisposed()) {
        observer.onNext(t);
    }
}

简要介绍下isDisposed()这个方法，该方法为true时表示订阅被中断，为false时正好相反。在这里面当!isDisposed()为true时表示订阅未被中断，此时执行observer.onNext(t);这个observer正是通过CreateEmitter构造方法传递进来的，也就是subscribeActual方法所接收的观察者对象。因此observer和CreateEmitter之间的onNext方法就是通过这种方式建立的联系，onComplete和onError同理。

至此，observer和CreateEmitter之间的关联就分析完了。还有一个问题，就是上面的步骤1中留下来的问题，就是这个subscribeActual方法所接收的observer是不是我们订阅时传进去的observer观察者？我们就返回到最初的订阅代码：

image.png

这个subscribe执行了哪些操作呢？我们点进去看看：

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

从上面的方法中我们可以很明显的看出subscribeActual(observer)中接收的observer正式来自于我们订阅时传入的观察者，在Observable类中subscribeActual方法是一个抽象方法，需要其子类去实现，在上面的思路梳理中我们得出的结论是Observable.create生成的具体Observable对象是其子类ObservableCreate；然后ObservableCreate调用subscribe方法完成订阅，因此此处执行的subscribeActual(observer);正是ObservableCreate内部的subscribeActual方法。

到这里我们的事件订阅流程就分析完了，最后我们再来总结一下：

结论

• 1、Observable.create()方法接收一个ObservableOnSubscribe接口类型的对象（source），并将这个接收的对象作为参数传递到ObservableCreate类的构造方法中生成一个Observable子类对象ObservableCreate对象（new ObservableCreate(source)），最后将其返回作为事件源（被观察者）。
• 2、然后调用subscribe(observer)方法，实际上执行的是observableCreate.subscribe(observer)。在这个方法中调用subscribeActual(observer);其参数正是我们前面自己写的observer对象（观察者）。而在subscribeActual(observer)方法内部，首先将传入的observer包装为CreateEmitter对象（parent），然后执行observer.onSubscribe(parent)。至此观察者和被观察者之间正式建立订阅关系。

• 3、最后执行方法source.subscribe(parent)，这个方法实际上是ObservableOnSubscribe接口中的方法，也就是我们自己手写的ObservableOnSubscribe实现类中的方法：

  
  
  image.png
  
  

  在上图中，emitter就是传入的parent，也就是结论2中将外部传进来的observer包装起来的CreateEmitter对象。因此，当我们调用emitter.onNext,onComplete,onError等方法时，实际上调用的是CreateEmitter内部的onNext,onComplete,onError方法；在CreateEmitter内部的onNext,onComplete,onError方法中，又调用了observer.onNext,onComplete,onError方法，这个observer正是外部传进来的观察者对象，如下图所示：

  
  
  image.png

好了，整个的时间订阅流程终于分析完了，当然了有事件订阅自然就有取消订阅，下一章RxJava2笔记（二、事件取消流程）我们将分析事件是如何取消订阅的。