RxJava模式与原理-----map变换操作符原理

map示意图：

RxJava代码

        // ObseravbleCreate  自定义source传递进去了 == source
        Observable.create(

                // 自定义source
                new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> e) throws Exception {

                    }
                })

                //  ObseravbleCreate.map
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws Exception {
                        return null;
                    }
                })

                // ObservableMap.subscribe 链式调用
                .subscribe(

                        // 自定义观察者（终点）
                        new Observer<Bitmap>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Bitmap bitmap) {

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        });

源码分析

.subscribe()会调用ObservableMap里面的subscribeActual函数

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

subscribeActual(observer); 调用的是ObservableMap里面的subscribeActual函数，传入的参数是自定义观察者(观察者)
因为这是ObservableMap点出来的订阅

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }

自定义观察者(观察者) 传到 subscribeActual 后 又做了个包裹(1) new MapObserver<T, U>(t, function)
把 自定义观察者(观察者) 传入 MapObserver
source.subscribe (new MapObserver<T, U>(t, function)); 上一层是 ObseravbleCreate
ObseravbleCreate . subscribe 再进入ObseravbleCreate的subscribeActual

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

传入的observer是 自定义观察者(终点)包裹(1)
包裹(1)再被 CreateEmitter parent = new CreateEmitter(observer); 包裹成包裹(2)

observer.onSubscribe(parent); 调用第一个最先启动的函数（底端）

source.subscribe(parent); 上一层 也就是自定义source，就执行到.create()里面了（顶端）

                // 自定义source
                new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> e) throws Exception {

                    }
                })

在.create()里面调用了包裹(2).onNext() 查看发射器中的onNext()

        @Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

observer.onNext(t); 又拿到了下一层的onNext
包裹(1).onNext
进入了ObservableMap里面的onNext

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

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

            U v;

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

.apply(t) 把 类型转换接口

public interface Function<T, R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Exception on error
     */
    R apply(@NonNull T t) throws Exception;
}

真正的实现就在代码中： 它规定规则 我们来干活

                //  ObseravbleCreate.map
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws Exception {
                        return null;
                    }
                })

逻辑图

装饰模式