RxJava2源码解析

源码总结：

Observabel 通过create方法。将ObservableOnSubscribe对象传递给自己。

通过subscribe方法。创建ObservableEmitter发射器对象。发射器里又封装了Observer。发射器又作为参数传递

给ObservableOnSubscribe对象的subscribe(ObservableEmitter<Integer> e)方法。当发射器调用onNext方法时。

会调用封装在自己内部的Observer的onNext方法；Observer将customer封装在自己内部；Observer调用Onnext方法时

会调用customer的accept方法；

一、代码的调用

//创建被观察者

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        for (int i = 0; i < 10000; i++) {
            e.onNext(i);
        }
    }

//通过subscribe连接被观察着和观察者

}).subscribe(

//创建观察者

new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.e(TAG,integer + "");
    }
});

二、分析create方法和subscribe方法

1 create方法返回 new ObservableCreate<T>(source)；

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

分析ObservableCreate

source即是一开始创建的这个对象

注意红色字体处。parent作为参数传递给source。即e = parent;而parent又封装了Observer.

new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        for (int i = 0; i < 10000; i++) {
            e.onNext(i);
        }
    }

将source传递给ObservableCreate

在subscribeActual方法里将Observer 和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 {

//在subscribeActual方法里将Observer 和source建立联系

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

//这个方法为parent的方法。所有parent.OnNext(),即是调用Oberver.onNext;Customer又被封装在

LambdaObserver里。

LambdaObserver.onNext会调用customer的accept；

@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()) {
        observer.onNext(t);
    }
}

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete, Consumer<? super Disposable> onSubscribe) {
    ObjectHelper.requireNonNull(onNext, "onNext is null");
    ObjectHelper.requireNonNull(onError, "onError is null");
    ObjectHelper.requireNonNull(onComplete, "onComplete is null");
    ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

    LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

    subscribe(ls);

    return ls;
}

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