RxJava2 (六)map操作符源码阅读

当前版本 2.2.19
RxJava2 (一)订阅流程源码阅读
RxJava2 (二)取消订阅流程 dispose( ) 源码阅读
RxJava2 (三)线程切换源码阅读
RxJava2 (四)切换UI主线程源码阅读
RxJava2 (五)just操作符源码阅读
RxJava2 (六)map操作符源码阅读

代码示例

Observable<Integer> observable1 = Observable.just(1, 2, 3);
// 可以将被观察者发送的数据类型转变成其他的类型
Observable<String> observable2 = observable1.map(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return "I'm " + integer;
    }
});
observable2.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");
    }
});

概述

1. observable1对象的真实类型为ObservableFromArray,它内部保存着待发射的数据源数组.
2. observable2对象的真实类型为ObservableMap,它持有一个ObservableFromArray对象引用.
3. .subscribe(Observer)方法后的API调用流程.
   • ObservableMap.subscribe(Observer)⬇
   • ObservableMap.subscribeActual(Observer)⬇
   • ObservableFromArray.subscribe(MapObserver)⬇
   • ObservableFromArray.subscribeActual(MapObserver)⬇
   • FromArrayDisposable.run()⬇
   • MapObserver.onNext(value)⬇这一步会执行关键的Function.apply()方法,将上游发射的数据进行转换操作后再发送到下游.
   • Observer.onNext(value)⬇

observable1执行流程可以看上一篇文章

observable2创建

看map()方法

// 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()

• 按照概述流程,调用.subscribe()最终会调用ObservableFromArray.FromArrayDisposable.run()发射数据.
• ObservableFromArray.FromArrayDisposable.run()发射数据发射数据最终会委托给MapObserver.onNext(value)方法.

public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array; // 待发射的数据源数组
    }
    @Override
    public void subscribeActual(Observer<? super T> observer) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(observer, array);
        ...
        // 使用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];
                ...
                // downstream类型为MapObserver,最终委托给该对象发射数据
                downstream.onNext(value);
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }
    }
}

• MapObserver.onNext(value)发射数据

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;// Function对象
    }
    @Override
    public void subscribeActual(Observer<? super U> t) {
        // 创建MapObserver对象
        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);// 观察者
            this.mapper = mapper;// Function对象
        }
        @Override
        public void onNext(T t) {
            ...
            // 这里调用Function对象的apply()方法,并且将MapObserver发射的数据传入.
            v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            // downstream对象就是用户创建的观察者,至此,观察者终于接收到数据了.
            downstream.onNext(v);
        }
    }
}

• Function.apply(t)

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;
    }
}