Rxjava2來分析一波

這裏主要講一下rxjava2在面試中回答點。
1、rxjava2的基本使用

   Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("1");  //發起事件源
                emitter.onNext("2");
                emitter.onNext("3");
                emitter.onComplete();

            }
        }).flatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                return Observable.just(s);
            }
        }).map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return null;
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "integer = " + integer);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                });

關於使用這裏就不過多的介紹來，主要說一下map和flatmap的區別。
map和flatmap功能是一致的都是爲了轉換對象，map可以轉換爲任意對象，而flatmap只能轉換成ObservableSource對象。

2、rxjava2訂閱流程和事件源發出流程分析。
任務鏈的構建：
每次調用一個操作符，都會生成一個被觀察者對象，並且這個被觀察者對象持有上一個被觀察者的引用，來看一下create操作符的實現。
在Observable中調用cretae操作符代碼如下

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

返回了一個ObservableCreate的被觀察者對象，裏面傳了一個source對象，這個source相當要監聽的事件源（就相當於source發生了改變它會告訴ObservableCreate對象，observableCrate，接着告訴下一個被觀察者）。
接着在observableCrate的基礎上又調用了flatmap的操作符，看一下代碼

     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
            boolean delayErrors, int maxConcurrency, int bufferSize) {
       //省略代碼
        return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
    }

生成了一個新的觀察者ObservableFlatMap，並持有ObservableCreate對象的引用。
接着的map subcribeOn道理一樣就不分析了，直接看最後一個observeOn這個操作符代碼如下

 @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    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));
    }

最後直接調用ObservableObserveOn的subcribe方法。
此時從crete到observeOn形成了一個鏈條，下層的被觀察者對象持有上一層被觀察者的引用，這就爲逆序訂閱打下基礎。

來看一下ObservableObserveOn的subcribe方法，最終會調用ObservableObserveOn的scribeActual方法具體代碼如下

   @Override
    protected void subscribeActual(Observer<? super T> observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();

            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }

生成一個這一層的觀察者對象ObserveOnObserver並持有下一層的觀察者的引用，這是爲事件下發作準備，然後用上一層的觀察者引用調用subcribe方法註冊這個觀察者對象，就這樣從下到上層層註冊。

當事件源觸發的時候會從上到下的出發每一層的觀察者最終到我們自己實現的觀察者。

AndroidSchedulers.mainThread() 最終是通過handler將上游的數據切換到祝線程的。
Schedules.IO 會創建一個創建一個runnable對象，將上一層的訂閱放在這個runnable對象的run方法裏面，這個runnable也會被扔進一個線程池中執行。

3、rxjava2使用注意的問題等。
內存泄漏問題（autodispose）和錯誤處理忘記寫
autodispose 原理及其使用