定义一个方法用来处理异步源的每一个结果，对这些结果进行一种转换变成新的数据，然后继续下发给原来的observer。

1、Observable

public final void subscribe(@NonNull Observer<? super T> observer) {
    observer = RxJavaPlugins.onSubscribe(this, observer);
    subscribeActual(observer);
}

2、ObservableMap

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
 
    public ObservableMap(ObservableSource<T> source, Function function) {
        super(source);//just相关的Observable
        this.function = function;
    }
}

public void subscribeActual(Observer<? super U> t) {
    //模板模式：调用抽象类Observable
    source.subscribe(new MapObserver<T, U>(t, function));
}

2.1、MapObserver

Map相关的观察者。

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;
    }
    
   
    public void onNext(T t) {
        if (done) {
            return;
        }
        if (sourceMode != NONE) {
            downstream.onNext(null);
            return;
        }
        U v = mapper.apply(t);//执行map功能
        downstream.onNext(v);//调用自定义观察者之onNext
    }
}

2.2、BasicFuseableObserver

public abstract class BasicFuseableObserver{
   
    public BasicFuseableObserver(Observer<? super R> downstream) {
        this.downstream = downstream;
    }
    
    public final void onSubscribe(Disposable d) {
        if (DisposableHelper.validate(this.upstream, d)) {
            this.upstream = d;
            if (beforeDownstream()) {
                //调用自定义的观察者
                downstream.onSubscribe(this);
                afterDownstream();
            }

        }
    }
}

3、ObservableFromArray

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) {//MapObserver
        FromArrayDisposable<T> d = new FromArrayDisposable<>(observer, array);
        observer.onSubscribe(d);//BasicFuseableObserver#onSubscribe
        d.run();
    }

    static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {

        final Observer<? super T> downstream;

        final T[] array;

        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.downstream = actual;//MapObserver
            this.array = array;
        }

        void run() {
            T[] a = array;
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                ...
                downstream.onNext(value);//MapObserver#onNext
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }
    }
}

4、示例

public static void map(){

    Observable.just(12,13)//ObservableFromArray
            .map(new Function<Integer, Object>() {
        // 将基本类型的事件转换为实体类 MapObservable
        @Override
        public Object apply(Integer integer) throws Throwable {
            MapObservable mapObservable = new MapObservable();
            mapObservable.setAge(integer);
            System.out.println("map integer = " + integer);
            return mapObservable;
        }
    }).subscribe(observer);
}

4.1、初始化过程

初始化过程也是Observable类型的中间操作符初始化过程。每级中间操作符的source属性指向其上级中间操作符。

4.2、订阅者过程

订阅者过程也是从后往前执行中间操作符的过程。通常Observable类型的中间操作符都存在Observer观察者类型的静态内部类。通过当前操作符的source属性以其对应的Observer观察者作为参数继续调用抽象类Observable的subscribe方法。

响应式编程之Map