大话 RxJava 核心原理

先说一个故事，带着故事看代码更有带入感。

警察队长，（每次执行的任务他也不知道具体是什么任务，用泛型）

每次在执行任务的时候，都需要创建一个新的警察+线人的组合

警察 + 中间人（就是观察者）（需要将中间人给到队长，队长在下发任务的时候，告诉中间人，中间人---》最后话带到）

泛型如果转化。假如现在队长，叫抓的是 A ，但是呢，A 的照片太模糊了，根本看不出来相貌 。当前在执行任务的警察
呢只要看见你，长的像的就抓住，交给他的下级就抓了 B，这样下级线人只知道要抓的人就是 B，给押送回去了 ，压根不知道队长给的是A
这样就完成了，泛型转化。所以要考虑抓犯人的过程是比较耗时的，需要放到子线程中。

（主线程就好比是吃饱饭的线人，子线程就是没有吃饱饭的线人，警队对线人有严格的管理制度，只要有线人不吃饭那么所有线人都不能吃）
线程切换，队长在往下发任务给，线人的时候，下级给到上级的线人就是没有吃饭的。那么基本上在这一条任务上面所有的线人都是没有吃饭在
干活的。（这个发生在把线人交给上级的时候，线人就提前是个什么状态，这个就是发生在 观察者上溯期间完成）这个时候，来了一个领导警察
看见线人都是在饿肚子，他就发话了先吃饭，吃饱了再干活，这个饭就是 Handler。于是乎这个警察在把任务交给下一个线人的时候，都是吃饱
饭的，这样就从没有吃饱到吃饱饭的转化，也就是从子线程到主线程的转化。

上级持有下级的引用（中间人，就是这个观察者），结合图可能会更好的理解一点。

上代码（警察队长和警察的故事情节代码实现）

public abstract class Observable<T> {
    public static <T> Observable<T> create(Observable<T> observable) {
        return observable;
    }

    public Observable<T> flatMap() {
        return new Observable<T>() {
            @Override
            public void subscribe(Observer<T> observer) {
                Observer<T> observerB = new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        observer.onNext(t);
                    }

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

                    @Override
                    public void onError(Throwable e) {
                        observer.onError(e);
                    }
                };
                Observable.this.subscribe(observerB);
            }
        };
    }

    public <R> Observable<R> map(Fun1<T, R> fun1) {
        return new Observable<R>() {
            @Override
            public void subscribe(Observer<R> observer) {
                Observer<T> observerB = new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        R r = fun1.call(t);
                        observer.onNext(r);
                    }

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

                    @Override
                    public void onError(Throwable e) {
                        observer.onError(e);
                    }
                };
                Observable.this.subscribe(observerB);
            }
        };
    }

    public Observable<T> switchThread() {
        return new Observable<T>() {
            @Override
            public void subscribe(Observer<T> observer) {
                new Thread() {
                    @Override
                    public void run() {
                        Observer<T> observerB = new Observer<T>() {
                            @Override
                            public void onNext(T t) {
                                observer.onNext(t);
                            }

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

                            @Override
                            public void onError(Throwable e) {
                                observer.onError(e);
                            }
                        };
                        Observable.this.subscribe(observerB);
                    }
                }.start();
            }
        };
    }

    private final Handler mHandler = new Handler(Looper.getMainLooper());

    public Observable<T> switchMain() {
        return new Observable<T>() {
            @Override
            public void subscribe(Observer<T> observer) {
                Observer<T> observerB = new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                observer.onNext(t);
                            }
                        });

                    }

                    @Override
                    public void onComplete() {

                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                observer.onComplete();
                            }
                        });
                    }

                    @Override
                    public void onError(Throwable e) {
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                observer.onError(e);
                            }
                        });
                    }
                };
                Observable.this.subscribe(observerB);
            }
        };
    }

    /**
     * 订阅一个观察者
     *
     * @param observer
     */
    public abstract void subscribe(Observer<T> observer);

}

看执行效果（发消息，切换线程，任务完成）

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 警察队长一开始是不知道具体任务的，<String> 就是给的具体任务
        Observable.create(new Observable<String>() {
                    @Override
                    public void subscribe(Observer<String> observer) {
                        Log.i("TTTTT", "1subscribe: " + Thread.currentThread().getName());
                        observer.onNext("我们要执行一个重要的任务，请告诉你下面线人通知下去");
                    }
                })
                .map(new Fun1<String, Bitmap>() { // 把线人交给自己的上级
                    @Override
                    public Bitmap call(String s) {
                        // 抓犯人，用自己的具体方式去抓。
                        Log.i("TTTTT", "收到上级的任务 （" + s + ")" + Thread.currentThread().getName());
                        return null;
                    }
                }).switchThread()// 没有吃饭的线人从这个地方产生
                .map(new Fun1<Bitmap, Bitmap>() {
                    @Override
                    public Bitmap call(Bitmap bitmap) {
                        Log.i("TTTTT", "4subscribe: " + Thread.currentThread().getName());
                        return null;
                    }
                }).switchMain()// 善良的警察，让线人吃饱，是从这里开始
                .subscribe(new Observer<Bitmap>() {
                    @Override
                    public void onNext(Bitmap bitmap) {
                        Log.i("TTTTT", "3subscribe: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onComplete() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }
                });
    }

执行效果（任务完成）