Rxjava2源码学习（一）

这一篇主要看一下Rxjava的链式调用（Builder设计模式） 和 数据如何实现传输。

首先看一下下面这个简单的代码片段：

Observable.create(new ObservableOnSubscribe<String>() {
       @Override
       public void subscribe(ObservableEmitter<String> emitter) throws Exception {
           emitter.onNext("test");
       }
   })
   .subscribeOn(Schedulers.io())
   .observeOn(AndroidSchedulers.mainThread())
   .subscribe(new Observer<String>() {
       @Override
       public void onSubscribe(Disposable d) {

       }

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

       @Override
       public void onError(Throwable e) {

       }

       @Override
       public void onComplete() {

       }
   });

链式调用

我们先看一下链式调用的实现：
Rxjava采用的是链式调用，比如我们看一下Observable.create（）方法

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

那返回的RxJavaPlugins.onAssembly又是什么呢？

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

我们可以看到，返回的是一个Observable对象！

所以Observable.create()之后得到的是一个Observable对象，接着看

.subscribeOn(Schedulers.io())

通过上面我们可以知道，RxJavaPlugins.onAssembly返回的是Observable对象，所以subscribeOn方法中返回的也是一个Observable对象。

public final Observable<T> subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}

两者不同的是new的对象不一样。

class ObservableCreate<T> extends Observable<T>

class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T>
class AbstractObservableWithUpstream<T, U> extends Observable<U>

但是他们都是继承自Observable。

接着我们看

.observeOn(AndroidSchedulers.mainThread())

public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

不是猜，返回的也是Observable对象

class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T>
class AbstractObservableWithUpstream<T, U> extends Observable<U>

通过不断的返回Observable对象，实现了链式调用。

数据传输

数据传输的核心思想是接口的回调机制来实现的，通过接口的定义声明和具体实现来完成数据的传输。
不妨先回忆一下RecyclerView的item点击事件。
RecyclerView本身是没有item的点击事件的，那我们自己写的时候是如何实现呢？
我们一般先定义一个点击事件的Listener。

interface ItemClickListener{
    fun setOnItemClick(position: Int)
}

我们在Adapter中声明这个点击事件，在item的需要点击的地方，例如整个item，对viewHolder.setOnClickListener的具体实现中，声明我们定义的Listener，例如listener.setOnItemClick。

holder.itemView.setOnClickListener {
   listener!!.setOnItemClick(position)
}

然后我们在Activity或者Fragment中，我们需要实现这个Listener，这样我们在点击item的时候，通过viewHolder实现的点击事件，再通过自定义的Listener的声明，我们在Activity或者Fragment中的Listener的具体实现中就能拿到我们需要的数据，例如position了。

adapter.setItemClickListener(object : ItemClickListener{
    override fun setOnItemClick(position: Int) {
        //接口具体的实现
    }

})

Rxjava中数据传输的本质也是通过上述的方式实现的。
这里的数据传输暂时不包括线程切换这一块。

还是拿上面的例子去掉线程切换这块来说：

 Observable.create(new ObservableOnSubscribe<String>() {
   @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("test");
    }
})
.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {

    }

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

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

Observable.create(new ObservableOnSubscribe<String>() {
   @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("test");
    }
})

我们以create方法为例，create方法将ObservableOnSubscribe接口的具体实现的地址作为source，

return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));

在create方法中，通过new ObservableCreate(source)创造一个observable对象（ObservableCreate对象继承自Observable）。最后调用RxJavaPlugins.onAssembly(new ObservableCreate(source));返回该Observable对象

我们来看一下ObservableCreate类是怎么做的：
ObservableCreate继承自Observable，实现了它的subscribeActual(Observer

protected abstract void subscribeActual(Observer<? super T> observer);

我这里只保留了关键代码

public final void subscribe(Observer<? super T> observer) {

        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {

        }
    }

当Observable调用subscribe方法时，真正调用的是subscribeActual方法。
那我们回到ObservableCreate类中看看subscribeActual方法做了什么：

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

这里首先new了一个CreateEmitter（数据发射器），构造函数中加入了Observable的Subscribe方法中传入的Observer对象。然后

source.subscribe(parent);

这里的source就是上面create的时候传入的ObservableOnSubscribe对象。到这里为止，有没有联想到之前提的recycleview点击事件的例子？

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

ObservableOnSubscribe是一个接口，它的subscribe方法中需要的是一个数据发射器，在Observable的create方法中new一个ObservableOnSubscribe对象作为source之后，这个source在ObservableCreate类中订阅了发射器，拿到了我们刚new出来的CreateEmitter对象（类似于recycleview例子中adapter中拿到的position），在外部的ObservableOnSubscribe的具体实现中我们拿到了这个CreateEmitter对象，用于发射数据。

同理我们在反过来，在Observable中的create方法中，ObservableOnSubscribe的subscribe方法中我们拿到了CreateEmitter对象，

public interface ObservableEmitter<T> extends Emitter<T> 

继承自Emitter接口

public interface Emitter<T> {

    /**
     * Signal a normal value.
     * @param value the value to signal, not null
     */
    void onNext(@NonNull T value);

    /**
     * Signal a Throwable exception.
     * @param error the Throwable to signal, not null
     */
    void onError(@NonNull Throwable error);

    /**
     * Signal a completion.
     */
    void onComplete();
}

在外部调声明接口，并调用它的方法

emitter.onNext("test");

在内部的CreateEmitter类中有它的具体实现

static final class CreateEmitter<T> implements ObservableEmitter<T>{
    @Override
    public void onNext(T t) {

        //关键代码
        observer.onNext(t);

    }
}

这里的思想像是之前RecyclerView例子的翻转，在外部对于接口的声明，在内部实现它，并做下一步的处理。

到此数据就通过ObservableOnSubscribe对象拿到的ObservableEmitter发射器，调用发射数据的代码，到达了其具体实现的地方，我们可以看到，在其具体实现的地方，调用了

observer.onNext(t);

这里的本质是和第一步获取发射器是一样的。

.subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

在外部是Observer对象的具体实现，作为参数传入subscribe方法中。通过

subscribeActual(observer);

进入到ObservableCreate类中，再通过

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

进入到CreateEmitter类中，在CreateEmitter的具体实现，例如onNext方法中，声明这个接口的方法，上面已经提到过了：

static final class CreateEmitter<T> implements ObservableEmitter<T>{
    @Override
    public void onNext(T t) {

        //关键代码
        observer.onNext(t);

    }
}

很熟悉是不是，这里是内部的Observer接口方法的调用，外部是接口方法的具体实现。

最后附上一张画的不是很好的原理图：