Rxjava2源码分析(2)——操作符

承接上一篇Rxjava2源码分析(1)
这一篇将讲下Rxjava2的操作符。在Rxjava里面最常用的是map操作符,接下来将从map入手分析。

1.map操作符的基本用法

这里按照国际惯例,先上map的基本用法。

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(@NonNull Integer integer) throws Exception {
                return "This is result " + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                mRxOperatorsText.append("accept : " + s +"\n");
                Log.e(TAG, "accept : " + s +"\n" );
            }
        });

2.map源码跟踪

2.1 map

跟踪map进去,进入Observable里面,你会发现同样有RxJavaPlugins.onAssembly这东西。

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上文已经说过了,这次主要关注ObservableMap。new ObservableMap<T, R>(this, mapper)里面的this是create返回的Observable对象,mapper是你给的Function对象。

2.2 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) {
        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> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            if (done) { //默认done为false,跳过
                return;
            }

            if (sourceMode != NONE) { //默认sourceMode 为0,跳过
                actual.onNext(null);
                return;
            }

            U v;

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

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

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

AbstractObservableWithUpstream

AbstractObservableWithUpstream是什么?它继承了Observable类,把ObservableSource对象保存了起来。

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {

    /** The source consumable Observable. */
    protected final ObservableSource<T> source;

    /**
     * Constructs the ObservableSource with the given consumable.
     * @param source the consumable Observable
     */
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }

    @Override
    public final ObservableSource<T> source() {
        return source;
    }

}

//1 mapper.apply(t)

在ObservableMap里面,subscribeActual,将完成上游Observable的订阅。MapObserver里面的mapper.apply(t)将上游的t转换成下游所需的U。这里怎么变换是你一开始时候就设定好的。这里我们当初传入map里面的Function如下。

new Function<Integer, String>() {
            @Override
            public String apply(@NonNull Integer integer) throws Exception {
                return "This is result " + integer;
            }
        }

//2 actual.onNext(v)

actual.onNext(v); 是交接给下游的Observer。actual对应本例就是当初create的对象,执行onNext方法就是执行当初自己定义的操作。

new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                mRxOperatorsText.append("accept : " + s +"\n");
                Log.e(TAG, "accept : " + s +"\n" );
            }
        }

至此,当初的e.onNext(1) 将得到响应。

总结一下。订阅过程是最后一个Observable往上一个Observable订阅(本例中是MapObserver)。从最后一个Observable里面的subscribe有个subscribeActual方法调用,这个方法会一层层订阅,直至第一个Observable。然后触发第一个Observable的subscribe,这里面会触发数据流操作。在本例中,订阅至到第一个Observable的subscribe实现类,里面的e.onNext(1); 会触发数据一层层往下流,下一个是MapObserver对数据的操作,到最后的Observable。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/loongago/article/details/80357813
文章标签: Rxjava
个人分类: Android
上一篇Rxjava2源码分析(1)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭