RxJava2 源码解析（二）

转载请标明出处：
http://blog.youkuaiyun.com/zxt0601/article/details/61637439
本文出自:【张旭童的博客】(http://blog.youkuaiyun.com/zxt0601)

概述

承接上一篇RxJava2 源码解析（一），
本系列我们的目的：

1. 知道源头(Observable)是如何将数据发送出去的。
2. 知道终点（Observer）是如何接收到数据的。
3. 何时将源头和终点关联起来的
4. 知道线程调度是怎么实现的
5. 知道操作符是怎么实现的

本篇计划讲解一下4,5.

RxJava最强大的莫过于它的线程调度 和 花式操作符。

map操作符

map是一个高频的操作符，我们首先拿他开刀。
例子如下，源头Observable发送的是String类型的数字，利用map转换成int型，最终在终点Observer接受到的也是int类型数据。：

        final Observable<String> testCreateObservable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("1");
                e.onComplete()
            }
        });

                Observable<Integer> map = testCreateObservable.map(new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        return Integer.parseInt(s);
                    }
                });
                map.subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe() called with: d = [" + d + "]");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "onNext() called with: value = [" + value + "]");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError() called with: e = [" + e + "]");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete() called");
                    }
                });

我们看一下map函数的源码：

    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        //判空略过
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        //RxJavaPlugins.onAssembly()是hook 上文提到过
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

RxJavaPlugins.onAssembly()是hook 上文提到过,所以我们只要看ObservableMap，它就是返回到我们手里的Observable:

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
   
    //将function变换函数类保存起来
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
   
        //super()将上游的Observable保存起来 ，用于subscribeActual()中用。
        super(source);
        this.function = function;
    }

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

它继承自AbstractObservableWithUpstream,该类继承自Observable，很简单，就是将上游的ObservableSource保存起来，做一次wrapper，所以它也算是装饰者模式的提现，如下:

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
   
    //将上游的`ObservableSource`保存起来
    protected final ObservableSource<T> source;
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }
    @Override
    public final ObservableSource<T> source() {
        return source;
    }
}

关于ObservableSource，代表了一个标准的无背压的 源数据接口，可以被Observer消费（订阅），如下：

public interface ObservableSource<T> {
    void subscribe(Observer<? super T> observer);
}

所有的Observable都已经实现了它,所以我们可以认为Observable和ObservableSource在本文中是相等的：

public abstract class Observable<T> implements ObservableSource<T> {
   

所以我们得到的ObservableMap对象也很简单，就是将上游的Observable和变换函数类Function保存起来。
Function的定义超级简单，就是一个接口，给我一个T，还你一个R.

public interface Function<T, R> {
    R apply(T t) throws Exception;
}

本例写的是将String->int.

重头戏，subscribeActua