RxJava2 (六)map操作符源碼閱讀

當前版本 2.2.19
RxJava2 (一)訂閱流程源碼閱讀
RxJava2 (二)取消訂閱流程 dispose( ) 源碼閱讀
RxJava2 (三)線程切換源碼閱讀
RxJava2 (四)切換UI主線程源碼閱讀
RxJava2 (五)just操作符源碼閱讀
RxJava2 (六)map操作符源碼閱讀

代碼示例

Observable.just(1, 2, 3)
        // 可以將被觀察者發送的數據類型轉變成其他的類型
        .map(new Function< Integer, String >() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "I'm " + integer;
            }
        })
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("onSubscribe");
                // 取消訂閱後,ObservableEmitter發出的消息,觀察者Observer將不會再收到.
                d.dispose();
            }
            @Override
            public void onNext(String s) {
                System.out.println("onNext: " + s);
            }
            @Override
            public void onError(Throwable e) {
                System.out.println("onError");
            }
            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        });

.map(Function mapper)

• Observable.just(1, 2, 3)將得到一個ObservableFromArray對象,當調用該對象的subscribe()方法時它將調用觀察者中的onNext()方法發送數據.
• .map(Function mapper)看看它.

// Observable類
public abstract class Observable<T> implements ObservableSource<T> {
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        // this:`ObservableFromArray`對象
        // mapper:用戶創建的Function對象,它有一個apply()方法
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }
}
// ObservableMap類
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);// `ObservableFromArray`對象
        this.function = function; //用戶創建的Function對象
    }
}

.subscribe()

• 當使用ObservableMap調用.subscribe()方法最終調用到ObservableMap.subscribeActual()方法.

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);// `ObservableFromArray`對象
        this.function = function; //用戶創建的Function對象
    }
    @Override
    public void subscribeActual(Observer<? super U> t) {
        // ObservableMap..subscribe()後會走到這裏.
        // source: ObservableFromArray對象,那接着就是調用ObservableFromArray.subscribe()
        // MapObserver對象中持有用戶創建的觀察者Observer引用以及用戶創建的Function引用對象.下面分析
        source.subscribe(new MapObserver<T, U>(t, function));
    }
    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);// 觀察者Observer對象
            this.mapper = mapper;// Function對象
        }
    }
}

• ObservableFromArray.subscribe()

// ObservableFromArray類
public final class ObservableFromArray<T> extends Observable<T> {
    @Override
    public void subscribeActual(Observer<? super T> observer) {
        // 參數observer其實爲MapObserver類型對象
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(observer, array);
        // 這裏調用的是MapObserver.onSubscribe()方法,最終就手動創建的Observer對象的onSubscribe()方法
        observer.onSubscribe(d);
        if (d.fusionMode) {
            return;
        }
        // d是FromArrayDisposable類型
        d.run();
    }
    static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
        void run() {
            T[] a = array;
            int n = a.length;
            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                ...
                // 最終使用MapObserver.onNext()方法將數據發送出去.
                // value就是待發射的數據
                downstream.onNext(value);
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }
    }
}

MapObserver.onNext(T) 如何發送數據

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);// 將觀察者Observer對象傳入父類構造中,使用downstream變量存儲起來
            this.mapper = mapper;// Function對象
        }
        @Override
        public void onNext(T t) {
            // 參數t就是just中待發射的數據
            ...
            try {
                // 在這裏將使用Function.apply()處理下just中的待數據
                // 示例代碼中apply()方法就是將just中傳入的數據加上"I'm "字符串然後返回.
                // 下面有分析
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
               ...
            }
            // 最終調用到了觀察者的onNext()方法
            downstream.onNext(v);
        }
    }
}

mapper.apply(t)

mapper是由用戶創建的Function類型對象

Function< Integer, String > mapper = new Function< Integer, String >() {
    @Override
    public String apply(Integer integer) throws Exception {
        // ObservableMap.MapObserver中執行onNext方法時會調用Function.apply(),對待發送的數據進行加工,然後返回值傳入到觀察者的Observer.onNext(v)方法中.
        return "I'm " + integer;
    }
}
// ObservableMap.MapObserver中執行onNext方法時會調用Function.apply(),對待發送的數據進行加工,然後返回值傳入到觀察者的Observer.onNext(v)方法中.
        return "I'm " + integer;
    }
}