RxJava2源碼分析——Map操作符

本文章主要是對RxJava2的Map操作符進行源碼分析，在閱讀之前，可以先閱讀以下文章：

RxJava2源碼分析——訂閱

RxJava2源碼分析——線程切換

本文章用的RxJava和RxAndroid版本如下：

implementation 'io.reactivex.rxjava2:rxjava:2.2.6'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

我們先寫段示例代碼，爲了方便理解，在調用map方法的時候，我就不用上Lambda和鏈式調用了，代碼如下：

Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
    emitter.onNext(100);
    emitter.onComplete();
})
        .map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer.toString();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                // no implementation
            }

            @Override
            public void onNext(String s) {
                Log.i("TanJiaJun", "變換後的：" + s);
            }

            @Override
            public void onError(Throwable e) {
                // no implementation
            }

            @Override
            public void onComplete() {
                // no implementation
            }
        });

這段代碼是將Integer類型的數據100變換爲String類型的100後發射出去。

源碼分析

我們看下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));
}

參數是泛型接口Function<? super T, ? extends R>，有兩個類型參數，第一個參數是一個下邊界通配符（Lower Bounded Wildcard），對應逆變，可以存放T或T的父類型，第二個參數是一個上邊界通配符（Upper Bounded Wildcard），對應協變，可以存放R或R的子類型。

根據前幾篇文章的經驗可知，我們只要看ObservableMap這個類就行了，代碼如下：

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        // source是上游Observable
        super(source);
        this.function = function;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {
        // 調用了上游Observable的subscribe方法，傳入new出來的MapObserver對象，第一個參數是下游Observer，第二個參數是Function泛型接口
        source.subscribe(new MapObserver<T, U>(t, function));
    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            // actual是傳進來的下游Observer，mapper是傳進來的Function泛型接口
            super(actual);
            this.mapper = mapper;
        }

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

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

            // U是要轉變的對象
            U v;

            try {
                // 調用了Function泛型接口的apply方法，這是我們要重寫的方法，參入的參數是轉變前的對象
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            // 調用onNext方法，把轉變後的對象發射出去
            downstream.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qd.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}

我的GitHub：TanJiaJunBeyond

Android通用框架：Android通用框架（Kotlin-MVVM）

我的掘金：譚嘉俊

我的簡書：譚嘉俊

我的CSDN：譚嘉俊