RxJava源码分析（二）：常用操作符

一、map操作符

map操作符的作用是将被观察者Observable发送的数据在apply()方法中转化成自己需要的返回到下游Observer的onNext()方法中。例：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onComplete();
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer s) throws Exception {
                if (s > 2) {
                    return "aaa";
                }
                return "bbb";
            }
        }).subscribe(new Observer<String>() {
            ...
            @Override
            public void onNext(String s) {
                Log.e("==============", "===onNext==>" + s);
            }
            ...
        });

map操作符将Observable发送的Integer类型参数1、2、3、4通过条件判断转化成"aaa"、”bbb"返回到Observer的onNext()方法中。

先来看一下map()方法的源码：

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

RxJavaPlugins.onAssembly()是hook,这里不管，只看ObservableMap，ObservableMap是Observable的子类，所以他就是我们返回得到的Observable

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    //保存Function对象
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        //通过super调用父类的构造方法保存传进来的Observable对象
        super(source);
        this.function = function;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        //保存Function对象
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            //通过super调用父类的构造函数保存MapObserver对象,即Observer对象
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            ...

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

        ...
    }
}

1. ObservableMap<T, U>继承AbstractObservableWithUpstream<T,U>，ObservableMap<T, U>构造函数传进来的Observable对象保存在AbstractObservableWithUpstream<T,U>中。(ObservableSource是Observable的顶层接口，所有的Observable都实现了ObservableSource)
2. 调用map()方法返回Observable订阅Observer时,调用subscribe()由上一节可知会调用subscribeActual()方法，这里调用的ObservableMap中的subscribeActual()方法：

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }

3. 在subscribeActual()方法中会创建MapObserver对象订阅上游的Observable对象。
4. 在MapObserver中，上游Observable发送的数据会传递到MapObserver的onNext方法中，function会调用apply()方法将上游需要的数据传递进去返回下游观察者所需要的数据，下游Observer调用onNext方法将apply()的返回值传进去。

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

订阅流程总结：

1. Observer订阅了map返回的MapObservable。
2. 在MapObservable被订阅时会创建一个MapObserver用来订阅上游的Observable。
3. 在MapObserver中，Function通过apply()方法将上游传来的参数转化后传递到下游的观察者。