[RxJava学习]操作符flatMap源码分析

与上文的思路相同，先写出常见的调用方式，然后逐句代码替换；最后根据代码执行顺序，理出调用关系。

首先，借用文章：RxJava基本流程和lift源码分析中flatMap的使用例子。

1.map和flatMap的创建参数都是Func1，之前一直没有想明白为啥要用flatMap。这里根据现有的学习程度总结如下：

我们都习惯于处理入参是基本类型的数据源，当Func1>时，flatMap下游显然比map的下游更幸福，call(Observable fileObservable)里的函数实现该是怎样的一个处理啊

        ArrayList folders = new ArrayList<>();
        Observable.from(folders)
                .map(new Func1>() {
                    @Override
                    public Observable call(File file) {
                        return Observable.from(file.listFiles());
                    }
                })
                .subscribe(new Action1>() {
                    @Override
                    public void call(Observable fileObservable) {
                        
                    }
                });

        ArrayList folders = new ArrayList<>();
        Observable.from(folders)
                .flatMap(new Func1>() {
                    @Override
                    public Observable call(File file) {
                        return Observable.from(file.listFiles());
                    }
                })
                .subscribe(new Action1() {
                    @Override
                    public void call(File file) {
                        
                    }
                });

所以，当我们发现数据源的转换不能从A到B一步搞定时，我们就要考虑中间加一个过渡的Observable，如果A-> Observable->B可以满足目标，那使用flatMap再合适不过；

2.下面我们开始以上面的例子来分析源码，上面代码等价于：

Observable.from(onSubscribe1)  
        .flatMap(transformer1)
        .subscribe(subscriber1);

其中：

    public static  Observable from(Iterable iterable) {
        return create(new OnSubscribeFromIterable(iterable));
    }

所以这里的onSubscribe1为：

onSubscribe1 = OnSubscribeFromIterable (dataSource);

其中dataSource就是folders。

transformer1为：

transformer1 = new Func1>() {
                    @Override
                    public Observable call(File file) {
                        return Observable.from(file.listFiles());
                    }
                };

逐句替换的过程如下：

3.代码执行逻辑如下：

接上图，继续分析代码流：

从上述流程图可以看到，Iterable类型的数据源的每项数据，都会进行transformer1的处理，然后输出一个Observable类型的新数据，该新数据源的每项数据都将会一次发射给初始的订阅者subScriber1（准确点说应该是下游最临近的订阅者）。

4.附上相关源码：

//OnSubscribeFromIterable
    public void call(final Subscriber o) {
        final Iterator it;
        boolean b;
        
        try {
            it = is.iterator();
            
            b = it.hasNext();
        } catch (Throwable ex) {
            Exceptions.throwOrReport(ex, o);
            return;
        }
            
        if (!o.isUnsubscribed()) {
            if (!b) {
                o.onCompleted();
            } else { 
                o.setProducer(new IterableProducer(o, it));
            }
        }
    }

//IterableProducer
        public void request(long n) {
            if (get() == Long.MAX_VALUE) {
                // already started with fast-path
                return;
            }
            if (n == Long.MAX_VALUE && compareAndSet(0, Long.MAX_VALUE)) {
                fastpath(); // for(;;)
            } else 
            if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
                slowpath(n); // for(;;)
            }

        }

//MergeSubscriber
static final class MergeSubscriber extends Subscriber> {
        final Subscriber child; 
        MergeProducer producer;
        volatile Queue