rxjava lift源码解析

最近在看给Android开发者的RxJava详解这篇文章，前面的都能理解，看到变换的原理——lift()这块的时候，我的脑袋直接懵逼了，每个单词我都认识，都能理解，但是连起来就看晕了，因此我花费了一些时间自行阅读源码来理解lift的原理，通过本篇文章记录一下，怕以后又给忘记了（大概率）。

首先我们来的看一个简单的rxjava的demo：

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello");
                subscriber.onNext(",");
                subscriber.onNext("world!");
                subscriber.onCompleted();
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                LogUtils.i("onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                LogUtils.i("onError");
            }

            @Override
            public void onNext(String string) {
                LogUtils.i(string);
            }
        })

相信不少新童鞋刚开始看到这些单词的时候有点晕乎乎的，Observable不是被观察者吗，怎么反而订阅了观察者Observer呢？其实可以简单的换个概念，Observable可以看成一个view，Subscriber看成OnClickListener，subscribe()订阅方法看成setOnClickListener（吐槽一下,这个subscribe如果命名成setOnSubscriber好理解很多）。进入subscribe()源码：

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        if(subscriber == null) {
            throw new IllegalArgumentException("observer can not be null");
        } else if(observable.onSubscribe == null) {
            throw new IllegalStateException("onSubscribe function can not be null.");
        } else {
            ((Subscriber)subscriber).onStart();
            if(!(subscriber instanceof SafeSubscriber)) {
                subscriber = new SafeSubscriber((Subscriber)subscriber);
            }

            try {
                hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
                return hook.onSubscribeReturn((Subscription)subscriber);
            } catch (Throwable var6) {
                Throwable e = var6;
                Exceptions.throwIfFatal(var6);
                if(((Subscriber)subscriber).isUnsubscribed()) {
                    RxJavaPluginUtils.handleException(hook.onSubscribeError(var6));
                } else {
                    try {
                        ((Subscriber)subscriber).onError(hook.onSubscribeError(e));
                    } catch (Throwable var5) {
                        Exceptions.throwIfFatal(var5);
                        RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + var6.getMessage() + "] and then again while trying to pass to onError.", var5);
                        hook.onSubscribeError(r);
                        throw r;
                    }
                }

                return Subscriptions.unsubscribed();
            }
        }
    }

这段代码里咱们需要关注的只有两行，首先在订阅的时候调用了subscriber.onStart()方法（所以如果有UI的操作如显示progressDialog不能放在onStart，因为它跟订阅处在一个线程里，应该放到doOnSubscribe()），然后调用了onSubscribe.call()，这个就是最开始create传进来的onSubscribe对象。

至此，rxjava发送事件逻辑咱们就弄清楚了，接下来看lift究竟是如何将事件进行变换的。以下代码中，使用lift方法将string事件变换成integer事件：

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                String s1 = "11";
                String s2 = "22";
                LogUtils.e("发送字符串事件："  + s1);
                subscriber.onNext(s1);
                LogUtils.e("发送字符串事件："  + s2);
                subscriber.onNext(s2);
                subscriber.onCompleted();
            }
        }).lift(new Observable.Operator<Integer, String>() {
            @Override
            public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
                return new Subscriber<String>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable throwable) {

                    }

                    @Override
                    public void onNext(String s) {
                        subscriber.onNext(Integer.valueOf(s));
                    }
                };
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable throwable) {

            }

            @Override
            public void onNext(Integer integer) {
                LogUtils.e("收到数据：" + integer);
            }
        });

按前面的demo，咱们的OnSubscribe发送的事件类型是String，为何在subscriber中接收到的却是integer对象呢？我们看一下lift方法里到底做了什么：

public final <R> Observable<R> lift(Observable.Operator<? extends R, ? super T> operator) {
        return new Observable(new OnSubscribeLift(this.onSubscribe, operator));
    }

只有简简单单的一行代码，新建了一个Obsevable对象，并且参数为一个新的OnSubscriberLift（继承OnSubscribe）对象。

PS：为方便读者理解，这里定义：

         1、create返回的为observable1，lift返回的为observable2

         2、create中传入的为onSubscribe1，lift中新建的为onSubscribe2

         3、subscribe()中传入的为subsribe1，operator返回的为subscribe2

来看看这个类里到底做了啥：

public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
    final OnSubscribe<T> parent;
    final Operator<? extends R, ? super T> operator;

    public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
        this.parent = parent;
        this.operator = operator;
    }

    public void call(Subscriber<? super R> o) {
        try {
            Subscriber st = (Subscriber)hook.onLift(this.operator).call(o);

            try {
                st.onStart();
                this.parent.call(st);
            } catch (Throwable var4) {
                Exceptions.throwIfFatal(var4);
                st.onError(var4);
            }
        } catch (Throwable var5) {
            Exceptions.throwIfFatal(var5);
            o.onError(var5);
        }

    }
}

根据前面分析，subscribe()方法会调用到onSubscribe.call，所以这里是subscribe1.subscribe() -> observable2.onSubscribe2.call，也就是走到上面的代码，

new Observable(new OnSubscribeLift(this.onSubscribe, operator));

这个parent就是我们传入的this.onSubscribe，也就是onSubscribe1，它的call传入了一个st，这个st就是operator.call返回的subscriber对象。对，就是前面那个new出来的subscriber2。所以onSubscribe1.call - > subscriber2.onNext，而subscriber2.onNext里，我们写了一行这样的代码

subscriber.onNext(Integer.valueOf(s));

这样subscriber到底是不是我们要的subscriber1呢？是不是感到很激动，最终的答案就要揭晓了。没错，operator.call()方法里，传入了一个subscriber参数o，这个o正是demo里咱们调用subscribe()方法时传进来的subscriber对象，也就是subscriber1，看上图代码可以知道，最终经过转换传回给了subscriber1。流程图如下图所示：

由图不难分析，lift方法相当于给原本的Observable加了一层代理，subscriber不能直接访问到onSubscribe，必须由lift()中间做一层事件的处理转换。