RxJava2的中轴线

RxJava2的基础UML

image

如图，RxJava2的所有实现几乎围绕上图中最基础的UML关系图进行。其中1为Observable被观察者，2为Observer观察者，3为Emitter发射源。发射源可以被取消，发射源被取消之后，一般情况下Observer可能就收不到信息了。这三者关系，也就构成RxJava中一个核心的关系图，首先Observable订阅了Observer，并且通过Emitter进行事件发射，发射过程中通知Observer需要进一步做什么处理（如observer.onNext()）;

看一个最基本的例子：

Observable.create(new ObservableOnSubscribe<String>() {

    @Override
    public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
        observableEmitter.onNext("hello world");
    }
}).subscribe(new io.reactivex.Observer<String>() {
    @Override
    public void onSubscribe(Disposable disposable) {

    }

    @Override
    public void onNext(String s) {
        Log.d("RXJava2", "welcome: " + s);
    }

    @Override
    public void onError(Throwable throwable) {

    }

    @Override
    public void onComplete() {

    }
});

我们基于上面的UML关系图，分析最基本简单的使用情况。

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

Observable.create()如上，RxJavaPlugins暂时不管，可以用于hook，这里直接返回ObservableCreate的实例，如下：

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

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

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

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

    }
}

查看UML图，ObservableCreate继承Observable。当Observable订阅Observer的时候，既调用Observable.subsribe(observer)的时候，这里的Observable为Observable.create之后的ObservableCreate实例，代码如下：

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");
        this.subscribeActual(observer);
    } catch (NullPointerException var4) {
        throw var4;
    } catch (Throwable var5) {
        Exceptions.throwIfFatal(var5);
        RxJavaPlugins.onError(var5);
        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(var5);
        throw npe;
    }
}

继而调用到ObservableCreate类的subscribeActual方法

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

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

    }

subscribeActual实现中，会创建一个Emiter发射器，这个发射器可以用来干嘛，既可以发射，也可以让他disposable，表示是否已经处理了。this.source.subscribe(parent)就绘制执行例子中的subsrube方法，这里source即使create的时候创建的ObservableOnSubscribe实例，执行的subscribe如下，我们让发射器observableEmitter执行onNext，这里表示发射器进行了事情发射，那么观察者Observer当然会收到信息了（前提是没被dispose）

new ObservableOnSubscribe<String>() {

    @Override
    public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
        observableEmitter.onNext("hello world");
    }
}

如下为ObservableCreate订阅的时候对应的发射器类。接上面的执行OnNext方法，则会接着执行this.observer.onNext(t)，而这里的observer即为例子中创建的obserer实例，继而输出log日志：welcome：hello world

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

    public void onNext(T t) {
        if (t == null) {
            this.onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        } else {
            if (!this.isDisposed()) {
                this.observer.onNext(t);
            }

        }
    }
}

通过上面的分析，我们要知道，RxJava2的所有操作基本离不开三个角色，Observable被观察者，Observer观察者，以及Emitter发射器，通过这三个角色的变现，RxJava提供了各种复杂的处理以及各种Observable变种。但原理离不开我们这一篇所说的中轴线。接下来分析各种Observable变种