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