rxjava ： compose 与 ObservableTransformer、lift 与 ObservableOperator

compose 与 ObservableTransformer ：

//操作被观察者（abstract class Observable<T> implements ObservableSource<T> ）



//将源ObservableSource整体转换
//通过对它应用特定的Transformer函数来转换ObservableSource。 
//此方法在ObservableSource本身上运行，而{@link #lift}在ObservableSource的Observers上运行。 
//如果要创建的运算符旨在作用于源ObservableSource发出的单个项目，请使用{@link #lift}。
//如果您的运算符旨在将源ObservableSource整体转换为
//（例如，通过对其应用一组特定的现有RxJava运算符），请使用{@code compose}。
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));
}



/**
 * 组成可观察对象的接口。
 *
 * @param <Upstream> the upstream value type
 * @param <Downstream> the downstream value type
 */
public interface ObservableTransformer<Upstream, Downstream> {
    /**
     * 对上游Observable应用一个函数，并返回带有可选不同元素类型的ObservableSource。
     * @param upstream the upstream Observable instance
     * @return the transformed ObservableSource instance
     */
    @NonNull
    ObservableSource<Downstream> apply(@NonNull Observable<Upstream> upstream);
}

lift 与 ObservableOperator ：

//操作ObservableSource中的值，即对源发出的单个项目进行操作
public final <R> Observable<R> lift(
						ObservableOperator<? extends R, ? super T> lifter) {
    ObjectHelper.requireNonNull(lifter, "onLift is null");
    return RxJavaPlugins.onAssembly(new ObservableLift<R, T>(this, lifter));
}



//操作【观察者】 : public interface Observer<T> 
/**
 * 将【下游观察者】映射/包装到【上游观察者】的接口。
 *
 * @param <Downstream> the value type of the downstream
 * @param <Upstream> the value type of the upstream
 */
public interface ObservableOperator<Downstream, Upstream> {
    /**
     * Applies a function to the child Observer and returns a new parent Observer.
     * @param observer the child Observer instance
     * @return the parent Observer instance
     * @throws Exception on failure
     */
    @NonNull
    Observer<? super Upstream> apply(@NonNull Observer<? super Downstream> observer) ;
}

总结：

操作符	操作对象
compose	将源ObservableSource整体转换
lift	对源发出的单个项目进行操作

操作	操作结果
ObservableTransformer（转换器）	对上游Observable应用一个函数，并返回带有可选不同元素类型的ObservableSource
ObservableOperator（操作者）	将【下游观察者】映射/包装到【上游观察者】

compose 与 flatMap 区别：

compose()是唯一一个能从流中获取原生Observable 的方法，
因此，影响整个流的操作符（像subscribeOn()和observeOn()）需要使用compose()，
相对的，如果你在flatMap()中使用subscribeOn()/observeOn()，它只影响你创建的flatMap()中的Observable,而不是整个流。

当你创建一个Observable流并且内联了一堆操作符以后，compose()会立即执行，flatMap()则是在onNext()被调用以后才会执行，换句话说，flatMap()转换的是每个项目，而compose()转换的是整个流。

flatMap()一定是低效率的，因为他每次调用onNext()之后都需要创建一个新的Observable，compose()是操作在整个流上的。

Transformer 作用：

Transformer，顾名思义是转换器的意思。

早在 RxJava1.x 版本就有了Observable.Transformer、Single.Transformer和Completable.Transformer，

在2.x版本中变成了ObservableTransformer、SingleTransformer、CompletableTransformer、FlowableTransformer和MaybeTransformer。
其中，FlowableTransformer和MaybeTransformer是新增的。
由于 RxJava2 将Observable拆分成 Observable 和 Flowable，所以多了一个FlowableTransformer。
同时，Maybe是 RxJava2 新增的一个类型，所以多了MaybeTransformer。

Transformer 能够将一个 Observable/Flowable/Single/Completable/Maybe 对象转换成另一个 Observable/Flowable/Single/Completable/Maybe 对象，和调用一系列的内联操作符是一模一样的。