Rxjava2.0之compose操作符

用途

对Observable流进行整体的变换，一般用于把一个或多个操作符封装起来，便于复用

用法

        Observable.just(-1,0,1,2,3)
                .compose(positiveNumber())
                .compose(schedulersTransformer())
                .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {}

                    @Override
                    public void onNext(Integer value) {
                        LogTool.d("number --> " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        LogTool.d("eeeeeeeeee");
                    }

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

1.positiveNumber方法，如果有负数或0，直接抛异常。

// An highlighted block
private <T extends Integer> ObservableTransformer<T, T>  positiveNumber() {
        return upstream -> upstream.flatMap(it -> {
            if (it.intValue() > 0) {
                return Observable.just(it);
            } else {
                return observer -> {
                    observer.onError(new Exception());
                };
            }
        });
    }

2.schedulersTransformer方法，线程调度。

private <T> ObservableTransformer<T, T> schedulersTransformer() {
        return new ObservableTransformer<T, T>(){
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io())
                               .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

说明

compose操作符接收一个ObservableTransformer对象，ObservableTransformer是一个接口，需要重写apply方法，apply方法接受一个Observable对象，返回一个ObservableSource对象，和flatmap操作符接收的Function对象很相似，都是重写apply方法。

/**
 * Interface to compose Observables.
 *
 * @param <Upstream> the upstream value type
 * @param <Downstream> the downstream value type
 */
public interface ObservableTransformer<Upstream, Downstream> {
    /**
     * Applies a function to the upstream Observable and returns an ObservableSource with
     * optionally different element type.
     * @param upstream the upstream Observable instance
     * @return the transformed ObservableSource instance
     */
    @NonNull
    ObservableSource<Downstream> apply(@NonNull Observable<Upstream> upstream);
}

特点

1.compose操作符是对流的整体操作，参数就是整个流
2.和flatmap操作符的区别：

1. flatmap对流的每个参数做操作，compose是对这个流做操作，所以可以在compose中再做flatmap，如前面的positiveNumber方法；
2. 执行时机的不同，flatmap是在onNext()被调用以后才会执行，compose则是立即执行；