Rxjava2 lift

看例子：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NotNull ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onComplete();
            }
        }).lift(new ObservableOperator<Integer, Integer>() {
            @NotNull
            @Override
            public Observer<? super Integer> apply(@NotNull Observer<? super Integer> observer) throws Exception {
                return new Observer<Integer>() {
                    @Override
                    public void onSubscribe(@NotNull Disposable d) {
                    }
                    @Override
                    public void onNext(@NotNull Integer integer) {
                        observer.onNext(integer);
                        System.out.println("onNext : " + integer);
                    }

                    @Override
                    public void onError(@NotNull Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                };
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println("accept : " + integer);
            }
        });

看源码：

   public final <R> Observable<R> lift(ObservableOperator<? extends R, ? super T> lifter) {
        ...
        return RxJavaPlugins.onAssembly(new ObservableLift<R, T>(this, lifter));
    }

遇到lift就等于把上下游切断了，原本交给下游的数据直接到lift所构造的Observer里面去了，要不要交给下游，就看lift了，apply方法中observer就是我们的下游，需要把数据给下游的就可以调用observer的onNext方法。相当于lift做了一个代理。

public final class ObservableLift<R, T> extends AbstractObservableWithUpstream<T, R> {
    /** The actual operator. */
    final ObservableOperator<? extends R, ? super T> operator;

    public ObservableLift(ObservableSource<T> source, ObservableOperator<? extends R, ? super T> operator) {
        super(source);
        this.operator = operator;
    }

    @Override
    public void subscribeActual(Observer<? super R> observer) {
        Observer<? super T> liftedObserver;
        try {
            liftedObserver = ObjectHelper.requireNonNull(operator.apply(observer), "Operator " + operator + " returned a null Observer");
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Disposable already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }

        source.subscribe(liftedObserver);
    }
}