这篇文章主要讲解 rxJava 使用的主要原理

rxJava hook

hook： 即为AOP 模式，后续会介绍Aop

rxJava 在做链式调用的.对中间逻辑添加无影响主要逻辑的，添加辅助逻辑

rxJava 的操作符，都会调用一个

针对 onObservableAssembly 做逻辑处理，setOnObservableAssembly,来添加Function 新的逻辑代码.

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //
        // 我想用了多少给 Map操作   flatMap
        // Hook之前的监听
        RxJavaPlugins.setOnObservableAssembly(new Function<Observable, Observable>() {
            @Override
            public Observable apply(Observable observable) throws Exception {
                Log.d(Flag.TAG, "apply: 整个项目 全局 监听 到底有多少地方使用 RxJava:" + observable);

                // 伪代码
                /*if (observable  === ObservableMap)
                    return null;*/

                return observable; // 不破坏人家的功能
            }
        });

        testHook();
    }

    /**
     * TODO RxJava Hook 点
     */
    public static void testHook() {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                e.onNext("A");
            }
        })
        .map(new Function<Object, Boolean>() {
            @Override
            public Boolean apply(Object o) throws Exception {
                return true;
            }
        })

        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {

            }
        })   ;
    }

订阅者模式

相对于传统观察者，订阅者模式，耦合性更低，属于一条线上下游之分

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 结论： new ObservableCreate() {source == 自定义source}
        // 2：Observable创建过程 源码分析
        Observable.create(

                // 自定义source
                new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                        // 发射器.onNext
                        emitter.onNext("A");
                    }
        })

        // 3：subscribe订阅过程 源码分析
        // ObservableCreate. subscribe
        .subscribe(
                // 自定义观察者
                // 1：Observer 源码看看
                new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

包裹模式

以多个map操作符为例子

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

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

        // ↓ObservableCreate.map   包裹模型中 最里面
        .map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return 45454;
            }
        })

        // ObservableMap.map
        .map(new Function<Integer, Boolean>() {
            @Override
            public Boolean apply(Integer integer) throws Exception {
                return true;
            }
        })

        // ↓包裹模型中最外面   往上走↑的时候在一层 层的剥开
        // ObservableMap.subscribe
        .subscribe(new Observer<Boolean>() {
            @Override
            public void onSubscribe(Disposable d) { }

            @Override
            public void onNext(Boolean bool) {
                Log.d(Flag.TAG, "onNext bool:" + bool);
            }

            @Override
            public void onError(Throwable e) { }

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

上流进入下流，建造者模式一层加一层，下层解刨上上层逻辑来影响最终结果，

透过subscribeActual 解析上层，observer.onSubscribe(listener);监听上上层逻辑，影响下层

装饰者模式

在原来的基础上修改做出新的展示，和纯粹的建造者模式区别，建造者是组成