理解RxJava（二）操作符流程原理分析

概述

在我的上一篇文章《理解RxJava（一）基本流程源码分析》
中，通过Observable.create().subscribe()的原理进行了简单的分析。

今天尝试对多个操作符的链式调用进行分析，示例代码：

    @Test
    public void test() throws Exception {
        Observable.create((ObservableOnSubscribe<Integer>) e -> {
            e.onNext(1);
            e.onNext(2);
            e.onComplete();
        }).map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer i) throws Exception {
                return i + 10;
            }
        })
          .doOnNext(new Consumer<Integer>() {
              @Override
              public void accept(Integer i) throws Exception {
                      System.out.println("doOnNext : i= " + i);
              }
          })
          .subscribe(i -> System.out.println("onNext : i= " + i));
    }

输出结果：

doOnNext : i= 11
onNext : i= 11
doOnNext : i= 12
onNext : i= 12

回溯

先回顾 上文 的内容：

  • 1.Observable.create()，实例化ObservableCreate和传入最上游数据源ObservableOnSubscribe
  • 2.Observable.subscribe(),实例化ObservableEmitter,负责发射数据
  • 3.执行Observer.onSubscribe()回调
  • 4.执行ObservableOnSubscribe.subscribe()方法,依次发射数据

Map操作符

回到本文中案例代码，我们以使用频率最高的map操作符先进行探讨。

先看一下map()方法的代码内部：

    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        //...省略非核心代码，下同
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

仍旧先不讨论RxJava内部使用的钩子机制（hook），默认map内部方法执行的是，创建一个ObservableMap的对象：

//1.ObservableMap类继承了AbstractObservableWithUpstream类
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;
  
    //2.传入Function转换函数
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
    
  //3.实际订阅时执行的方法
    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

这个类有三点值得注意，我已经注释在源码中。

AbstractObservableWithUpstream

首先，来看继承的AbstractObservableWithUpstream类：

//实际上这个类的本质还是继承的Observable
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
    
    //这个成员变量存储的是上游的Observable
    protected final ObservableSource<T> source;

    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }

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

}

和ObservableCreate不同的是，ObservableMap继承了AbstractObservableWithUpstream这个Observable的装饰器，这个类的作用人如其名，就是用来“存储上游Observable”的Observable,这意味着我们目前可以把Observable和其装饰器分为两种：

  • 第一种，最上游数据源 型Observable，类似ObservableCreate，ObservableJust等等。
  • 第二种，类似ObservableMap，ObservableDoOnEach(下文马上讲到)，这些类实际上继承了Observable的装饰器AbstractObservableWithUpstream，而不是直接继承Observable。其作用就是在初始化的同时，将上游的Observable数据源作为成员变量存储起来。

总结一句话，第一种是起点Observable，第二种则是过程Observable。

Function函数

Function函数是Java8里面的一个接口：

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

//实际上就是本文案例代码中的：
new Function<Integer, Integer>() {
      @Override
      public Integer apply(Integer i) throws Exception {
            return i + 10;
      }
}

其作用就是把上游的数据进行变换，因此我们看到，在源码中，这个Function函数也被当做成员进行了存储，在订阅的时候通过ObservableMap.subscribeActual()作为参数传入。

subscribeActual()

由上文我们知道，当我们执行Observable.subscrbe(Observer o)的时候，实际上执行的就是对应的subscribeActual()方法：

    public final void subscribe(Observer<? super T> observer) {
        //...
        try {
            //...
            subscribeActual(observer);
        } catch (NullPointerException e) { 
            //...
        } catch (Throwable e) {
            //...
        }
    }

当ObservableMap执行subscribeActual()时，我们接收到一个下游的Observer参数，并将其和内部存储的function函数一起作为参数实例化了一个MapObserver对象，并交给上游数据源Observable进行订阅。

数据流的上游和下游

关于这个所谓“下游的Observer”，一定要理解，所谓上游下游，指的就是距离数据源的远近，这个是相对的，在本文案例中，很明显，Observable.Create相对其他操作就是上游，Observable.Map相对Observable.Create是下游，但是相对Observable.doOnNext和Observable.subscribe就是上游；当然，Observable.subscribe是订阅处，相对其它操作都是下游。

MapObserver

看一下MapObserver对象,这个类有很多有意思的地方，初学源码不多深入，先大概看一下onNext()的执行流程：

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) {
            //....
            U v;

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

很好理解，实际上MapObserver对象在执行onNext的时候，先执行funtion函数进行数据变换，将转换后的数据，传给下游传入的Observer，执行下游Observer的onNext方法。

值得一提的是，我们可以看到，在数据进行了转换之后，会将转换后的数据进行一次ObjectHelper.requireNonNull()非空校验，如果转换后的数据为空，则会抛出错误，这一点我们一定要注意，数据流的传递和转换过程中，一定要避免null值的情况。

关于Map操作符的原理分析先到此为止，我们接下来看一下doOnNext操作符。

doOnNext操作符

直接看内部代码：

    public final Observable<T> doOnNext(Consumer<? super T> onNext) {
        //实际上执行的是doOnEach方法
        return doOnEach(onNext, Functions.emptyConsumer(), Functions.EMPTY_ACTION, Functions.EMPTY_ACTION);
    }

我们看一下doOnEach()方法：

    private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onAfterTerminate, "onAfterTerminate is null");
        return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate));
    }

很简单，在进行简单的非空校验后，doOnNext()实际上是直接生成一个ObservableDoOnEach对象并返回。

这个onNext参数就是我们案例中的：

new Consumer<Integer>() {
      @Override
      public void accept(Integer i) throws Exception {
              System.out.println("doOnNext : i= " + i);
       }
  }

ObservableDoOnEach

有了Map操作符的经验，我们轻车熟路：

//1.同样继承AbstractObservableWithUpstream
public final class ObservableDoOnEach<T> extends AbstractObservableWithUpstream<T, T> {
    final Consumer<? super T> onNext;
    final Consumer<? super Throwable> onError;
    final Action onComplete;
    final Action onAfterTerminate;
  
    //2.构造器，存储对应函数，以及上游的Observable
    public ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext,
                              Consumer<? super Throwable> onError,
                              Action onComplete,
                              Action onAfterTerminate) {
        super(source);
        this.onNext = onNext;  //就是System.out.println("doOnNext : i= " + i);
        //这三个都是以默认参数传进来的
        this.onError = onError;
        this.onComplete = onComplete;
        this.onAfterTerminate = onAfterTerminate;
    }
  
    //实际订阅执行的方法
    @Override
    public void subscribeActual(Observer<? super T> t) {
        source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate));
    }
}

在案例代码中，doOnNext()在未subscribe订阅之前，将上游的数据源ObservableMap作为source成员变量存储，同时存储ObservableMap数据到来时，将要执行的函数onNext()

千万注意，这个onNext()不是我们subscribe时传入的onNext()，而是doOnNext()传入的：

System.out.println("doOnNext : i= " + i);

DoOnEachObserver

我们看下subscribeActual方法内部生成的这个DoOnEachObserver是何方神圣：

static final class DoOnEachObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> actual;
        final Consumer<? super T> onNext;
        final Consumer<? super Throwable> onError;
        final Action onComplete;
        final Action onAfterTerminate;

        Disposable s;

        boolean done;
        
        //1.构造器，实际上就是依赖注入
        DoOnEachObserver(
                Observer<? super T> actual,
                Consumer<? super T> onNext,
                Consumer<? super Throwable> onError,
                Action onComplete,
                Action onAfterTerminate) {
            this.actual = actual;
            this.onNext = onNext;
            this.onError = onError;
            this.onComplete = onComplete;
            this.onAfterTerminate = onAfterTerminate;
        }
        
        //2.执行onNext
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            try {
         //3.执行System.out.println("doOnNext : i= " + i);
                onNext.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                s.dispose();
                onError(e);
                return;
            }
         //4.执行下游Observer的onNext
            actual.onNext(t);
        }
        //......先忽略大部分代码，我们暂时只关注onNext
    }

先忽略线程调度和其他参数及相关方法，我们只关注onNext，实际上就是先执行doOnNext()：

System.out.println("doOnNext : i= " + i);

然后执行下游Observer的onNext，也就是：

System.out.println("onNext : i= " + i);

这也正好契合了我们上文的输出结果：

doOnNext : i= 11
onNext : i= 11
doOnNext : i= 12
onNext : i= 12

流程整理

其实到这里，还是有些乱，上游下游可能还是不能很好的看清。

先将代码再发一次：

    @Test
    public void test() throws Exception {
        Observable.create((ObservableOnSubscribe<Integer>) e -> {
            e.onNext(1);
            e.onNext(2);
            e.onComplete();
        }).map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer i) throws Exception {
                return i + 10;
            }
        })
          .doOnNext(new Consumer<Integer>() {
              @Override
              public void accept(Integer i) throws Exception {
                      System.out.println("doOnNext : i= " + i);
              }
          })
          .subscribe(i -> System.out.println("onNext : i= " + i));
    }

我们将创建和订阅分两步来讲：

创建

在未执行subscribe订阅之前，执行的流程应该是这样的：

本文借鉴图片来源，下同：RxJava2 源码解析——流程 @Robin_Lrange

图片是借鉴的，我们选择性忽略线程调度的两步，其他基本都是一致的。

订阅

订阅时，执行的流程变成了：

总结来说，当执行subscribe时，Observable中存储的上游的Observable 会被下游的Observer订阅：

    //以ObservableDoOnEach为例
    @Override
    public void subscribeActual(Observer<? super T> t) {
        source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate));
    }

可以看到，source是上游的ObservableMap,它被下游的DoOnEachObserver订阅。

我们不要忽视这个source实际上也是Observable的装饰器（ObserverMap），它也会执行其内部的subscribeActual方法：

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

是不是理解过来了？实际上就是装饰器模式的体现,这就是所谓的：

Observable中存储的上游的Observable 会被下游的Observer订阅。

即：

每一步都会生成对应的Observer对上一步生成并存储的Observable进行订阅。

这说明，在订阅时，实际上这个顺序是逆向的，从下游往上游进行订阅。

上游发射数据

当逆向订阅执行到最上游时，即ObservableCreate.subscribe()方法时，我们上文已经讲过了，会通过实例好的ObservableEmitter进行数据的发射，那么数据就会从上游到下游，一层层执行对应Observer的onNext方法：

和订阅不同，数据的传递和变换则是正常，方向从上游往下游进行依次处理，最终执行我们subscribe中传递的Observer.onNext()。

总结

  • 1.创建：订阅前，每一步都生成对应的Observable对象，中间的每一步都将上游的Observable存储；
  • 2.订阅： 每一步都会生成对应的Observer对上一步生成并存储的Observable进行订阅。订阅的执行顺序是由下到上的。
  • 3.执行：先执行每一步传入的函数操作，然后将操作后的数据交给下游的Observer继续处理。 数据的传递和处理顺序是由上到下的。

接下来我会尝试对RxJava最核心的线程调度的原理进行解析。

参考文章

1.RxJava2 源码解析——流程 @Robin_Lrange

感谢@Robin_Lrange的精彩文章和图片！

2.RxJava2 源码解析（二）@张旭童

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,117评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,328评论 1赞 293
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,839评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,007评论 0赞 206
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,384评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,629评论 1赞 219
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,880评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,593评论 0赞 198
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,313评论 1赞 243
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,575评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,066评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,392评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,052评论 3赞 236
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,082评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,844评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,662评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,575评论 2赞 270

推荐阅读更多精彩内容

  • RxJava 2.x 学习（转载）
    转载自：https://xiaobailong24.me/2017/03/18/Android-RxJava2.x...
    Young1657阅读 1,958评论 1赞 9
  • RxJava 2.x 学习2（转载）
    怎么如此平静, 感觉像是走错了片场.为什么呢, 因为上下游工作在同一个线程呀骚年们! 这个时候上游每次调用emit...
    Young1657阅读 1,400评论 2赞 1
  • Rxjava
    我从去年开始使用 RxJava ，到现在一年多了。今年加入了 Flipboard 后，看到 Flipboard 的...
    Jason_andy阅读 5,382评论 7赞 62
  • 你好
    嘿，你好 天还没亮，我恰好梦到 如果还年少 我会满世界去找
    沐天九歌阅读 162评论 0赞 0
  • 孩子的文字|时间
    【题记】 这是女儿上五年级时所写的一篇短文，一年前就发布在她自己的简书上了。 真的想不到，一个10岁的孩子居然对时...
    AZ雕刻孤独AZ阅读 181评论 6赞 6