Rxjava(2) map操作符

map操作符的作用是将事件流中的元素进行变换。

变换的原理是创建新的observable进行包装代理。

类图关系如下

以一下流程来分析过程

  Observable.just("")
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) throws Exception {
                        return s;
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }
                    @Override
                    public void onNext(String s) {
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onComplete() {
                    }
                });

1,subscribe在确定观察者后，调用subscribeActual方法，该方法的实例为上层的observable，即ObservableMap

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
 
            throw npe;
        }
    }

2，在map操作符传入变换接口实例后，创建了ObservableMap，把上层的observable和变换实例Function进行保存，并返回。

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
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));
}

3，执行创建的ObservableMap的subscribeActual方法。用上层的observable订阅MapObserver。MapObserver把下层的观察者和变换接口的实例保存起来。

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

4,上层的observa执行MapObserver的onNext，调用变换实例的apply方法，获取到返回值。传递到下层observer的onNext中。

	 static final class MapObserver<T, U> extends Observer<T, U> {
        final Function<? super T, ? extends U> mapper;
		Observer<? super U> actual;
        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
           this.actual =actual;
            this.mapper = mapper;
        }
        @Override
        public void onNext(T t) {
            U v;
            v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            actual.onNext(v);
        }
    }

中间部分，拿到上层的observable进行包装，拿到下层的observer进行包装，获取变换结果传递到下层。

map变换时序图