Rxjava - flapMap变换

Rxjava是一个异步框架，类似于AsyncTask，其优点在于让你的异步代码更简洁，阅读代码会更轻松。知己知彼，百战不殆。
我们从源码分析Rxjava原理，可以让我们更轻松的使用Rxjava，最主要还能学到Rxjava响应式编程的思想。

照例，先来个小例子：

Observable<String> originObservable = Observable.just("1", "2", "3");
Observable<Integer> flapMapObservable = originObservable.flatMap(new Func1<String, Observable<Integer>>() {
    @Override
    public Observable<Integer> call(final String s) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                Integer.parseInt(s);
            }
        });
    }
});
Observer<Integer> originObserver = new Observer<Integer>() {
    @Override
    public void onCompleted() {
        Log.e(getClass().getName(), "observer is completed");
    }
    @Override
    public void onError(Throwable e) {
        Log.e(getClass().getName(), "observer is error");
    }
    @Override
    public void onNext(Integer s) {
        Log.e(getClass().getName(), "observer next value : " + s);
    }
};
flapMapObservable.subscribe(originObserver);

flatMap主要的作用是通过Func1

Observable<T> ----------------> Observable<R>

先看看flatMap方法：

// Observable类
public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
    if (getClass() == ScalarSynchronousObservable.class) {
        return ((ScalarSynchronousObservable<T>)this).scalarFlatMap(func);
    }
    return merge(map(func));
}

先调用map方法（请参考map变换），结果是：

// 调用map(func)，其中func属于Func1<? super T, ? extends Observable<? extends R>>类型
Observable<T> ----------------> Observable<Observable<R>>（暂且称为TempObservable）

然后调用了merge方法：

// Observable类
public static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source) {
    if (source.getClass() == ScalarSynchronousObservable.class) {
        return ((ScalarSynchronousObservable<T>)source).scalarFlatMap((Func1)UtilityFunctions.identity());
    }
    return source.lift(OperatorMerge.<T>instance(false));
}

OperatorMerge之后再分析，最终调用了TempObservable的lift方法：

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

创建了一个新的被观察者（也就是例子中的flapMapObservable），当我们调用

flapMapObservable.subscribe(originObserver);

那么OnSubscribeLift的call方法便会执行：

// OnSubscribeLift类
public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
    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;
        // 结合上面，这时的operator是OperatorMerge.<T>instance(false)
        this.operator = operator;
    }
    @Override
    public void call(Subscriber<? super R> o) {
        try {
            // 暂时先看做Subscriber<? super T> st = operator.call(o);
            Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);
            try {
                st.onStart();
                parent.call(st);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                st.onError(e);
            }
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            o.onError(e);
        }
    }
}

先调用了OperatorMerge的call方法：

// OperatorMerge类
@Override
public Subscriber<Observable<? extends T>> call(final Subscriber<? super T> child) {
    MergeSubscriber<T> subscriber = new MergeSubscriber<T>(child, delayErrors, maxConcurrent);
    MergeProducer<T> producer = new MergeProducer<T>(subscriber);
    subscriber.producer = producer;
    child.add(subscriber);
    child.setProducer(producer);
    return subscriber;
}

返回的是一个MergeSubscriber实例。
再回到OnSubscribeLift的call方法，然后调用了parent的call方法，parent为原始的OnSubscribe，当在parent的call方法中执行

// 此时的subscriber为MergeSubscriber
subscriber.onNext("1");

MergeSubscriber的onNext便会执行：

// MergeSubscriber类
@Override
public void onNext(Observable<? extends T> t) {
    if (t == null) {
        return;
    }
    if (t == Observable.empty()) {
        emitEmpty();
    } else
    if (t instanceof ScalarSynchronousObservable) {
        tryEmit(((ScalarSynchronousObservable<? extends T>)t).get());
    } else {
        InnerSubscriber<T> inner = new InnerSubscriber<T>(this, uniqueId++);
        addInner(inner);
        t.unsafeSubscribe(inner);
        emit();
    }
}

分析到这里，不知道你晕了没，反正我晕了，绕来绕去。一般我遇到这种情况，在我对框架有一定的理解后，我会尝试跟着框架的思想去写一下，或许能知道作者为什么这么设计。

看到这里，如果没有晕，请继续看代码分析，这里推荐一篇博文：RxJava1.0 flatMap方法的源码分析

如果晕了，请看我下一篇博文Rxjava - 简单实现。