Retrofit2＜三＞ rxJava 分析

rxJava體系比較大，為了收縮範圍還是從我實際開發用的著手。

private Observable request(Observable observable, int flag) {
    if (flag == SINGLE) {
        //Observable 對映
        return observable
                .map(this.functionSingle())
                .compose(schedulersTransformer());
    } else {
        return observable
                .map(this.functionList())
                .compose(schedulersTransformer());
    }
}

這裡對observable操作有兩種，一種是map，一種compose。

 public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

這個map方法傳入的引數是一個泛型類。Function，擁有兩個泛型引數一個是T，一個是R。這個T引數屬於Observable 構造物件攜帶的引數，大家要注意研究這個rxjava的時候，心中一定隨時關注這個Observable 物件，因為這個是RxJava的核心落腳點。看下Funtion 型別實際上是一個

public interface Function<T, R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Exception on error
     */
    R apply(@NonNull T t) throws Exception;
}

然後看下new ObservableMap<T, R>(this, mapper) 構造了一個ObservableMap。
有必要把整個ObservableMap 都貼出來。

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;
    //構造方法傳入引數。 
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }

   
    @Override
    public void subscribeActual(Observer<? super U> t) {
    //實際上是訂閱了一個觀察者。接下來關注這個觀察者的onNext方法，最終可以遇見肯定是要調到function的apply方法。其實RxJava本質就是傳入一堆物件，然後進行介面呼叫。
        source.subscribe(new MapObserver<T, U>(t, function));
    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }

            U v;

            try {
            //這個地方就是呼叫之前傳遞到的function的方法，其實這個也是對結果進行處理屬於增加觀察者的一種方式。
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qd.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}

現在再來分析 observalbe.compose(schedulersTransformer()); composer方法傳入的是ObservableTransformer 。從名稱來看，屬於觀察源的轉換。這個介面實際上就只有一個apply方法。我們現在看下。我們的實際用法中，subscribeOn（Scheduler）和 observeOn(Scheduler scheduler)這兩個方法對於安卓來說是非常重要並且明顯的。

  public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) {
        return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "composer is null")).apply(this));
    }

首先呼叫的apply方法。我們看下

   private ObservableTransformer schedulersTransformer() {
        return new ObservableTransformer() {
            @Override
            public ObservableSource apply(Observable upstream) {
                return upstream
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

現在把結論說明一下，subscribeOn 代表觀察源所跑的Scheduler，observeOn 代表觀察者也就是結果所在的執行緒，由於安卓都要求在主線中重新整理UI，所以這裡面直接用了跑在主執行緒的Scheduler。這兩個方法裡面的邏輯還是有點多。我們分開來講。
首先對subscribeOn 有個直觀解釋。我貼一個rx官網對這個api的介紹，相信都能看明白。
the SubscribeOn operator designates which thread the Observable will begin operating on。
指明Observable 應該被Schedulers.io()裡的thread 執行。observeOn 是指在指定shcedule的thread來接收這個事件。這兩個方法其實體現了rxjava的精髓，那就是可以做到執行緒切換，鏈式呼叫。事件產生
可以指定執行緒，並且可以對事件進行多次apply。傳遞到observe的時候也能做到執行緒指定，並且可以做到層層的攔截。
首先subscribeOn(Schedulers.io())

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

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        //此處方法是構造了一個SubscribeOnObserver 的parent。
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);

        observer.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer<? super T> downstream;

        final AtomicReference<Disposable> upstream;

        SubscribeOnObserver(Observer<? super T> downstream) {
            this.downstream = downstream;
            this.upstream = new AtomicReference<Disposable>();
        }

        @Override
        public void onSubscribe(Disposable d) {
            DisposableHelper.setOnce(this.upstream, d);
        }

        @Override
        public void onNext(T t) {
            downstream.onNext(t);
        }

        @Override
        public void onError(Throwable t) {
            downstream.onError(t);
        }

        @Override
        public void onComplete() {
            downstream.onComplete();
        }

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

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

        void setDisposable(Disposable d) {
            DisposableHelper.setOnce(this, d);
        }
    }

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

        SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            source.subscribe(parent);
        }
    }
}

現在要定位到Scheduler了，rxjava概念的另一個核心，（Obserable,Observe,Scheduler）。結合上面程式碼來分析下這個排程器。
IO = RxJavaPlugins.initIoScheduler(new IOTask());
這裡最終使用的是IoScheduler.