浅析rxjava(二)lift

上一篇说了rxjava基础的用法，这一篇来解析lift源码

rxjava提供了许多操作符，如map，flatMap，filter等，其实都是使用lift函数进行装换的。

我们来看一个例子：

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1111");
            }
        }).map(new Func1<String, Integer>() {
            @Override
            public Integer call(String s) {
                return Integer.valueOf(s + "2222");
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.v("next",String.valueOf(integer));
            }
        });

这个log会打印出来11112222，中间map操作符会把字符串类型转换成int类型。

我们来逐步查看流程。

1.首先create()方法没什么好说的了，就是把OnSubscribe存储到Observable实例中。

2.我们来看map方法

    public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
        return lift(new OperatorMap<T, R>(func));
    }

    public final <R> Observable<R> lift(final Observable.Operator<? extends R, ? super T> operator) {
        return new Observable<R>(new Observable.OnSubscribe<R>() {
            @Override
            public void call(Subscriber<? super R> o) {
                try {
                    Subscriber<? super T> st = hook.onLift(operator).call(o);
                    try {
                        st.onStart();
                        onSubscribe.call(st);
                    } catch (Throwable e) {
                        st.onError(e);
                    }
                } catch (Throwable e) {
                    o.onError(e);
                }
            }
        });
    }

其实是调用lift方法，传入一个OperatorMap实例，把Func1传入OperatorMap中，存储下来， 等下面有用，这里把OperatorMap代码贴出来

public final class OperatorMap<T, R> implements Operator<R, T> {

    private final Func1<? super T, ? extends R> transformer;

    public OperatorMap(Func1<? super T, ? extends R> transformer) {
        this.transformer = transformer;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        return new Subscriber<T>(o) {

            @Override
            public void onCompleted() {
                o.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                o.onError(e);
            }

            @Override
            public void onNext(T t) {
                try {
                    o.onNext(transformer.call(t));
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    onError(OnErrorThrowable.addValueAsLastCause(e, t));
                }
            }
        };
    }
}

然后我们看lift方法，发现重新new了一个Observable实例，这个和create方法是一样的，类似于把之前create里new的Observable给拦截了，并且新创建了一个OnSubscribe，然后call的实现方法我们先不看。

3.来看subscribe方法，和上一篇介绍一样，先把源码贴出来

    public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        return subscribe(new Subscriber<T>() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }

        });
    }
    public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }
    private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();

        try {
            hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
            return hook.onSubscribeReturn(subscriber);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            try {
                subscriber.onError(hook.onSubscribeError(e));
            } catch (OnErrorNotImplementedException e2) {
                throw e2;
            } catch (Throwable e2) {
                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                hook.onSubscribeError(r);
                throw r;
            }
            return Subscriptions.unsubscribed();
        }
    }  

(下面逻辑比较绕，可以通过打断点的方式，逐个查看流程)

直接看hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);这个方法，实际就是observable.onSubscribe.call(subscriber)，这里的onSubscribe不是最开始create存放的了，是map方法中新new的，所以这里调用call(subscriber)就走到lift()方法里call的回调里面了。

然后我们看Subscriber<? super T> st = hook.onLift(operator).call(o);这个方法，其实就是Subscriber<? super T> st = operator.call(o);这个方法，这里的operator实例是OperatorMap类型的，在上面的map方法里有写到。然后调用OperatorMap的call方法，上面源码已经贴出来了。

继续是st.onStart(); 和 onSubscribe.call(st);方法，onSubscribe是最开始create时候的实例(就是例子的第一步create的)，然后调用call方法，就回调到了subscriber.onNext("1111");这里，然后这里的subscriber就是刚刚OperatorMap call出来的，然后就走到了OperatorMap call 方法的回调里面了，执行 o.onNext(transformer.call(t));，这里面transformer是一个Func1的类型，这个实例是在new OperatorMap<T, R>(func)时传递进来的(就是在调用map方法的时候)。

然后就走到return Integer.valueOf(s + "2222");这里了，拿到值了(11112222)，这个o是在Subscriber<? super T> st = hook.onLift(operator).call(o);的时候传递进来的，而这个o就是在subscribe方法里new出来的，然后observer.onNext(t);，最后就到Log.v("next", String.valueOf(integer));这里，log打出11112222

写的很乱，可以通过打断点来观看流程