原理：

先看图：

结论：分为两个方向：第一就是没订阅之前第二订阅之后，没订阅之前就是上图中的黑色图，每调用一个操作符,这个操作符就持有上一个操作符所创建的observalbe(如map创建的observalbeMap 就是个代理)就这么一层一层往下包装下去，直到最后一个map调用了订阅方法，注意，没有订阅之前所有操作符中的代码都不会执行的除了（compose），由于持有上源那么就会一层层从最后往上找最后就会执行第一个Obserabel的订阅方法，在这个订阅方法中就会执行已经经过各个操作包装好的Observer的就会一层层剥开Observe，最终代用订阅的oberver中的oNext 方法

两句话总结：

顺流而下：操作符的调用如* *map的调用就是一层层往下传递源方便订阅的时候反着找到源头

逆流而上：就是拿到* *observer经过一层层包装把map的转换方法都封装里面，到源头时就一层层拆分调用订阅者的方法

compose操作符：

Compose 是操作被观察者的其他操作符是操作观察者的

compose()是唯一一个能够从数据流中得到原始Observable的操作符，（也就可以订阅之前拦截操作上一个被观察者代理）

compose看这篇文章： blog.csdn.net/jdsjlzx/art…

看下面代码：

Observable.*just*("XXXX").map(new Function<String, String>() {  
    @Override  
    public String apply(String s) throws Exception {  
        Log.*e*("onsucess1","MAP1----"+Thread.*currentThread*().getName());  
        return "";  
    }  
}).compose(new ObservableTransformer<String, String>() {  
    @Override  
    public ObservableSource<String> apply(Observable<String> upstream) {  
        Log.*e*("onsucess1","compose----"+Thread.*currentThread*().getName());  
        Observable<String> stringObservable = upstream.subscribeOn(Schedulers.*io*());  
        return stringObservable ;  
    }  
}).map(new Function<String, Object>() {  
    @Override  
    public Object apply(String s) throws Exception {  
        Log.*e*("onsucess1","MAP2----"+Thread.*currentThread*().getName());  
        return null;  
    }  
})

返回： 2023-01-06 22:05:38.386 6455-6455/com.key.calc.retrofit E/onsucess1: compose----main

2023-01-06 22:05:38.389 6455-6478/com.key.calc.retrofit E/onsucess1: MAP1----RxCachedThreadScheduler-2

2023-01-06 22:05:38.389 6455-6478/com.key.calc.retrofit E/onsucess1: MAP2----RxCachedThreadScheduler-2

线程调度：

subscribeOn()：设置源头也就是最开始的被观察者的订阅方法所执行的线程，位置随便，以最靠近源头的为准，也就是位置上游会覆盖下游

observeOn():设置观察者onNext所执行的线程，设置作用域为observeOn()位置往下的位置，如果下流还有一个observeOn()以这个往下的线程以这个observeOn()线程为准

结论：subscribeOn()指定了最开始执行线程，如果不改变则全部执行以这个指定为准，observeOn()可在流的任意位置改变线程

Rxjava浅谈

原理：