RxJava2.x源码解析(一)

一.引言

说到RxJava，我相信现在每个Android开发者对他都有一定的了解。怎么使用，不是我们今天要讨论的，本着知其然必知其所以然的态度，我们来挖一挖RxJava背后的实现。今天我们就从一个最简单的例子入手，不涉及线程调度，线程调度的实现我们留着下次去了解。
下面我们来举一个RxJava最简单的实现代码：

   Observable.create(new ObservableOnSubscribe<String>() {
            @Override
           public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                  emitter.onNext("sk");
                  emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                  //此处的Disposable其实和上有的emiiter是一个对象
                  Log.v("RxJavaTest","onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.v("RxJavaTest","onNext"+s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.v("RxJavaTest","onComplete");
            }
        });

二.源码解析

下面我们就从上述代码开始我们的源码解析。我们将上诉代码分三个步骤来解析：

1.调用Observable.create()方法
我们将这一步拆分成若干方法来讲解。

- (1)new ObservableOnSubscribe()
首先创建了一个ObservableOnSubscribe对象,可以理解为发送事件的上游，通过匿名内部类的方式。ObservableOnSubscribe是一个接口内部定义了一个方法subscribe()。

- (2)Observable.create()创建一个被观察者
源码如下：

    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        //就是返回一个ObservableCreate对象
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
    
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        //默认onObservableAssembly为null。
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        //直接返回source.即传入得ObservableCreate对象。
        return source;
    }

- (3)new ObservableCreate(source)
我们来看看通过构造方法创建的ObservableCreate对象是个什么东西。

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

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        //ObservableCreate内部的成员变量就是上述创建的ObservableOnSubscribe对象
        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的***subscribeActual()***方法，做了自己实现，实现内容我们下面在做分析。
到这一步我们可以知道，Observable.create()方法其实就是返回了一个ObservableCreate对象，对象内部通过一个成员变量source保存我们传入的ObservableOnSubscribe对象,也可以理解为我们的被观察者，ObservableCreate只是在我们的被观察者对象外面包装了一层。

2.调用new Observer();创建了一个观察者
Observer是一个接口，内部定义了四个方法。这里通过匿名内部类的方式创建了一个观察者。

public interface Observer<T> {
 void onSubscribe(@NonNull Disposable d);
 void onNext(@NonNull T t);
 void onError(@NonNull Throwable e);
 void onComplete();
}

3.subscribe()建立订阅关系

(1)Observable.subscribe()方法

  public final void subscribe(Observer<? super T> observer) {
         //校验输入的观察者不能为null
        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");
            //直接调用ObservableCreate的subscribeActual()方法，这个方法传入了一个观察者。
            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;
        }
    }

由上述代码我们可以知道，当我们调用subscribe()方法建立订阅关系的时候，其实就是调用我们第一步创建的ObservableCreate对象内部重写的subscribeActual()方法传入了一个观察者，下面我们来分析subscribeActual()方法的实现。

(2).ObservableCreate.subscribeActual()

    protected void subscribeActual(Observer<? super T> observer) {
        //通过传入的观察者对象创建一个事件发射器
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //调用观察者的onSubscribe()方法，传入一个发射器。
        observer.onSubscribe(parent);
        try {
            //source对象，就是传入的被ObservableOnSubscribe对象
            //调用它的subscribe()方法传入一个事件发射器
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

(3)new CreateEmitter(observer)
下面我们来看看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 (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
                //调用观察者的onNext()方法
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            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.");
            }
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
                return true;
            }
            return false;
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

        @Override
        public void setDisposable(Disposable d) {
            DisposableHelper.set(this, d);
        }

        @Override
        public void setCancellable(Cancellable c) {
            setDisposable(new CancellableDisposable(c));
        }

        @Override
        public ObservableEmitter<T> serialize() {
            return new SerializedEmitter<T>(this);
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        @Override
        public String toString() {
            return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
        }
    }

可以看到我们的CreateEmitter继承自AtomicReference，实现了ObservableEmitter, Disposable接口。通过成员变量observer存储传入的观察者。

(4).emitter.onNext(“sk”);
上面我们已经分析过了，这个emitter其实就是subscribeActual()方法内部创建的CreateEmitter对象，当我们调用emitter.onNext()方法时，其实就是调用了CreateEmitter的onNext方法，即Observer的onNext的方法，即观察者的onNext()方法。

好了，到这我们RxJava最简单的实现流程已经分析完成了。下面我们来做一个简单的总结。

三.总结

1.当我们调用Observable.create()其实就是创建了一个ObservableCreate对象。
2.ObservalueCreate类内部重写父类Observable的subscribeActual()方法
3.调用subscribe()方法传入观察者建立订阅关系的时候，其实就是调用2中重写的subscribeActual()方法。
4.subscribeActual()内部通过传入的Observer创建了CreateEmitter对象，CreateEmitter持有Observer的引用，然后又分别调用了ObservableOnSubscribe的subscribe方法和Observer的onSubscribe方法，传入的参数都是我们的CreateEmitter。所以当我们调用发射事件的方法即调用了CreateEmitter对象的onNext方法。onNext方法其实调用的就是Observer的onNext方法。这样事件就从被观察者传给了观察者，上游传到了下游。