RxJava 源码分析之 —— lift 变换

最新推荐文章于 2022-09-18 13:31:57 发布
最新推荐文章于 2022-09-18 13:31:57 发布
阅读量942 收藏
点赞数
分类专栏： rxjava Android 文章标签： 响应式 rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a153614131/article/details/52524992
版权

写在前面

rxjava 一直很火，我也用了一段时间，感觉特别好用。它属于响应式编程（Reactive Programming，以下简称 RP），脱胎于观察者模式。两者的对比如下：

  • 观察者模式：observable -> observer
  • 响应式编程：observable -> lift1 -> lift2 ->… ->observer

可以看到，RP 的特点是在观察的基础上，加入了传播路径上的变换（lift）。
这使得我们可以把数据变换逻辑提取出来，而不必全部杂糅在 observer 里。

我们称变换为 lift，是因为在 rxjava 里面，所有的变换都由一个叫 lift() 的函数实现。
具体而言，它可以是 map(), flatMap(), filter(), groupBy() 等等任何变换。

前戏也做足了，有请我们的主角 lift。
以下内容假定你已经熟悉 rxjava 的基本使用。
如不熟悉，可以先参看简单的介绍：

RxJava 初探（网络请求）


一个简单的流程

场景设计

下边要分析源码了，从简易的场景说起吧：

  1. 创建一个 Observable，它包含了数据 “hello rxjava.”。
  2. 然后订阅之，用 println() 打印出来。


我们按着数字 1～6 走一下流程：

    // 变量以 Str 结尾时为了提示该变量的范型是 String, 下同。。。
    private Observable.OnSubscribe<String> mOnSubscribeStr = new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) { // 3: 接收来自 subscribe（）的参数，即 mSubscriberStr
            subscriber.onNext("hello rxjava."); // 4: 生成数据 "hello rxjava.", 下发给订阅者 mSubscriberStr
        }
    };

    private Subscriber<String> mSubscriberStr = new Subscriber<String>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(String string) { // 5: 接收来自 mOnSubscribeStr 的数据
            System.out.println(string); // 6: 打印
        }
    };

    private void testSubscribe(){
        Observable.create(mOnSubscribeStr) // 1: 传入 mOnSubscribeStr, 保存之, 相当于传入一个 Callback
                .subscribe(mSubscriberStr); // 2: 传入 mSubscriberStr , 由 OnSubscribe.call() 接收
    }


源码分析

有几点要注意：

  1. 第一步中，mOnSubscribeStr 会被 Observable 保存下来，具体请看源码。

  2. 第二步中， subscribe() 里的 mSubscriberStr 参数最终会被传递到 3 处：OnSubscribe.call() 里面


所以，我们有理由相信，subscribe() 的实现基本是：mOnSubscribeStr.call( mSubscriberStr )。
事实上确实如此，各种重载版本的 subscribe(), 最终辗转调用到
Observable.subscribe(subscriber, observable)。我们来分析一下它：

// subscribe 内部实现
private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
    ...
    try {
        // allow the hook to intercept and/or decorate
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber); 
        // 看这行：这个 hook 基本**啥都不做**，返回一个 observable.onSubscribe，
        // 然后立马 .call(subscriber)，和我们的猜想一致。

        // 至于这个奇怪的 hook，按源码说的，包裹一层 hook 是为了 intercept and/or decorate
        // 反正这个 hook 之后还会反复出现，传入啥就传出啥，直接忽视即可
        return hook.onSubscribeReturn(subscriber);
    } catch (Throwable e) { ... }
}


变换

场景设计

到此为止，一个简单的流程走完了，一切都很完美。那么我们引入变换吧，先构造一个场景：

  1. 创建一个 Observable，它包含了数据 “hello rxjava.”。

  2. 做一个变换 string -> string.length()

  3. 然后订阅之，用 println() 打印出来。
    Observable.OnSubscribe<String> mOnSubscribeStr = new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello rxjava.");
        }
    };

    private Func1<String, Integer> mFuncStrToInt = new Func1<String, Integer>() {
        @Override
        public Integer call(String string) {
            return string.length(); // 1: string -> string.length()
        }
    };

    private Subscriber<Integer> mSubscriberInt = new Subscriber<Integer>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(Integer length) {
            System.out.println(length);
        }
    };

    private void testMap(){
        Observable.create(mOnSubscribeStr)
                .map(mFuncStrToInt) // 2: 把映射的 function 传进去，最后其实传给了 lift（）
                .subscribe(mSubscriberInt);
    }


山寨实现 map

这次就不走流程了，大体上是在之前的流程上插入了一段 map()。我们来想想怎么实现这个 map 呢？

咱们列一下需求，然后试着山寨一把，实现一个 myMap()：

  1. map 调用之后需要改变范型（String -> Integer）,
    这意味着我们需要 new 一个 Observable< Integer > 出来。

  2. new 了一个 ObservableInt 之后，我们的 subscribe 是针对这个新的 ObservableInt 的。
    我们必须与旧的 ObservableStr 建立起联系（让新的 ObservableInt 去订阅旧的 ObservableStr）。


实现如下，跟着流程 1～7 走一遍：

    // ---------- testMyMap ------------
    private static void testMyMap(){
        System.out.println("testMyMap: ");

        myMap(mObservableStr, mFuncStrToInt)    // 等价于 mObservableStr.map(mFuncStrToInt)
                .subscribe(mSubscriberInt); // 1: 传入 mSubscriberInt , 由 onSubscribeInt.call() 接收

        System.out.println("");
    }

    // 山寨版实现 －－ myMap()
    private static Observable<Integer> myMap(final Observable<String> observableStr
            , final Func1<String, Integer> func){

        Observable.OnSubscribe<Integer> onSubscribeInt = new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(final Subscriber<? super Integer> subscriberInt) { // 2: 接收 mSubscriberInt

                Subscriber<String> subscriberStr = new Subscriber<String>() {   // 3: 包裹 subscriberInt, 转换成 subscriberStr
                    @Override
                    public void onCompleted() {
                        subscriberInt.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        subscriberInt.onError(e);
                    }

                    @Override
                    public void onNext(String string) { // 5: 回溯到最上游 create 里, 再不断下发数据
                        Integer length = func.call(string); // 6: 变换
                        subscriberInt.onNext(length);   // 7: 下发新数据给下游
                    }
                };

                observableStr.subscribe(subscriberStr); // 4: 包裹了 mSubscriberInt 以后, 丢给上游 (即订阅了上游)
                // 等价于 mOnSubscribeStr.call(subscriberStr), 有点像责任链模式
            }
        };

        return Observable.create(onSubscribeInt);
    }
    // ---------- testMyMap ------------


看下输出效果：和官方的 map() 效果一致

testSubscribe: 
hello rxjava.

testMap: 
length = 13

testMyMap: 
length = 13


总结一下：

  1. 每次变换会 new 出一个 Observable，它们串成一个数据流。

  2. 下游 create 的时候，会 subscribe 上游，上下游之间是一种 订阅 —— 发布 关系。

  3. 最重要的一点，对于 map() 来说，责任只是配置，即设置好上／下游之间的监听。
    无论步骤 4 的 subscribe()，还是步骤 7 的 onNext() 都是嵌在回调里边。
    如果调用完 map() 而不去调用subscribe()，步骤 4 和 7 都不会被执行到 !!!
    打个比方，map 就像是把片子都下好了放在那里，你去不去看（subscribe）不关它的事= =。

感觉是一种奇怪的责任链模式，每个 Observable 只和前／后继（上／下游）是低耦合关系，与其他对象毫无关联。


官方 map 源码

// map
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
    return lift(new OperatorMap<T, R>(func)); // OperatorMap: 等于我们的步骤 5~7，变换、下发数据
}

// 先看 OperatorMap
// Operator<R, T>接口: 基本是把 Subscriber<R> 转换成 Subscriber<T>
public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {
}

// 这里的 <T, R> 故意反着传进去，有点绕体会一下
public final class OperatorMap<T, R> implements Operator<R, T> {
    private final Func1<? super T, ? extends R> transformer;

    public OperatorMap(Func1<? super T, ? extends R> transformer) {
        this.transformer = transformer;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        return new Subscriber<T>(o) { // 等于我们的步骤 3: 包裹 subscriberInt, 转换成 subscriberStr
            @Override
            public void onCompleted() { o.onCompleted(); }

            @Override
            public void onError(Throwable e) { o.onError(e); }

            @Override
            public void onNext(T t) {
                try {
                    o.onNext(transformer.call(t)); // 等于我们的步骤 5~7，变换、下发数据
                } catch (Throwable e) {
                    Exceptions.throwOrReport(e, this, t);
                }
            }
        };
    }
}

// 再看 lift
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return new Observable<R>(new OnSubscribe<R>() {
        @Override
        public void call(Subscriber<? super R> o) { // 等于我们的步骤 2: 参数 o 接收 mSubscriberInt
            try {
                Subscriber<? super T> st = hook.onLift(operator).call(o); // 等于我们的步骤 3:
                try {
                    ... 
                    this.onSubscribe.call(st); // 等于我们的步骤 4: 订阅上游

                } catch (Throwable e) { ... }
            } catch (Throwable e) { ... }
        }
    });
}


盗了张图来，有关这个回溯和下发的流程，生动又形象：

  • 每行的 lift 都 new 了一个 Observable，即每行的 Observable 都是不同的对象，从上到下为（上游 －>下游）
  • 向上的箭头：回溯，对应步骤 4： subscribe()
  • 向下的箭头：下发，对应步骤 7： onNext()

这里写图片描述

参考

RxJava基本流程和lift源码分析
快速理解RxJava源码的设计理念

源码

以下是本文测试代码的汇总，请放心食用（有个 main() 函数，直接能 run 起来）。

package com.example.jinliangshan.littlezhihu.home.rxjava;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Func1;

/**
 * Created by jinliangshan on 16/9/13.
 * 注意变量命名, 成员变量带前缀 m, 局部变量不带
 */
public class RxjavaTest {

    public static void main(String args[]){
        testSubscribe();
//        testMySubscribe();
        testMap();
        testMyMap();
    }

    // ---------- test ------------
    private static Observable.OnSubscribe<String> mOnSubscribeStr = new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello rxjava.");
        }
    };

    private static Observable<String> mObservableStr = Observable.create(mOnSubscribeStr);  // 数据源

    private static Subscriber<String> mSubscriberStr = new Subscriber<String>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(String string) {
            System.out.println(string);
        }
    };

    private static void testSubscribe(){
        System.out.println("testSubscribe: ");

        mObservableStr
                .subscribe(mSubscriberStr);

        System.out.println("");
    }
    // ---------- test ------------

    // ---------- testMySubscribe ------------
    private static void testMySubscribe(){
        System.out.println("testMySubscribe: ");

        mySubscribe(mObservableStr, mSubscriberStr);

        System.out.println("");
    }

    private static void mySubscribe(Observable<String> observableStr, Subscriber<String> subscriberStr){
        mOnSubscribeStr.call(subscriberStr);
    }
    // ---------- testMySubscribe ------------

    // ---------- testMap ------------
    private static Func1<String, Integer> mFuncStrToInt = new Func1<String, Integer>() {
        @Override
        public Integer call(String string) {
            return string.length();
        }
    };

    private static Subscriber<Integer> mSubscriberInt = new Subscriber<Integer>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(Integer length) {
            System.out.println("length = " + length);
        }
    };

    private static void testMap(){
        System.out.println("testMap: ");

        mObservableStr
                .map(mFuncStrToInt)
                .subscribe(mSubscriberInt);

        System.out.println("");
    }
    // ---------- testMap ------------

    // ---------- testMyMap ------------
    private static void testMyMap(){
        System.out.println("testMyMap: ");

        myMap(mObservableStr, mFuncStrToInt)    // 等价于 mObservableStr.map(mFuncStrToInt)
                .subscribe(mSubscriberInt); // 1: 传入 mSubscriberInt , 由 onSubscribeInt.call() 接收

        System.out.println("");
    }

    private static Observable<Integer> myMap(final Observable<String> observableStr, final Func1<String, Integer> func){

        Observable.OnSubscribe<Integer> onSubscribeInt = new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(final Subscriber<? super Integer> subscriberInt) { // 2: 接收 mSubscriberInt

                Subscriber<String> subscriberStr = new Subscriber<String>() {   // 3: 包裹 subscriberInt, 转换成 subscriberStr
                    @Override
                    public void onCompleted() {
                        subscriberInt.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        subscriberInt.onError(e);
                    }

                    @Override
                    public void onNext(String string) { // 5: 回溯到最上游 create 里, 再不断下发数据
                        Integer length = func.call(string); // 6: 变换
                        subscriberInt.onNext(length);   // 7: 下发新数据给下游
                    }
                };

                observableStr.subscribe(subscriberStr); // 4: 包裹了 mSubscriberInt 以后, 丢给上游 (即订阅了上游)
                // 等价于 mOnSubscribeStr.call(subscriberStr), 有点像责任链模式
            }
        };

        return Observable.create(onSubscribeInt);
    }
    // ---------- testMyMap ------------
}
梁山boy
关注
专栏目录
rxjava源码分析——2.scheduler实现线程切换
weixin_37587973的博客
06-10 197
rxjava最重要的功能是他异步工作的能力，基于上一篇文章对rxjava基本调用流程的分析，本文对rxjava异步工作流程进行探讨。 同上篇一样，我们这里先给出一个demo，后文基于这个demo进行分析。 demo package article; import rx.Observable; import rx.schedulers.Schedulers; public class AsyncTest { private static volatile int observerId = 1;
RxJava源码分析之subscribeOn和observeOn
茅屋
04-10 6206
RxJava源码分析之subscribeOn和observeOn RxJava的特色就是可以改变他的任务线程，可以很优雅的在子线程和主线程中切换，而切换用到的两个主要方法是subscribeOn()和observeOn(). 备注：因本人水平有限，以下分析只代表本人所见，如有不当，请见谅并指出。 subscribeOn()和observeOn()的区别 subscr
RxJava源码分析（一）
TomCat0916的博客
10-14 318
基本原理分析,线程切换代码运行流程分析
RxJava 源码分析
xiangkezhu的博客
05-06 180
首先分析 Observable.create操作符 例子： Observable observable = Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(@NonNull ObservableEmitter<String&gt...
RXJava源码分析
Allence的博客
09-18 968
流程分析：对于被观察者来说，装饰器模式体现在subscribeActual方法对于观察者来说，装饰器模式体现在onNext方法。
Rxjava源码分析
irXiang的专栏
12-04 277
Observable.create(new ObservableOnSubscribe() {             @Override             public void subscribe(ObservableEmitter emitter) throws Exception {                 Log.i("xiang","发射.1");        
RxJava学习经验谈——map与flatmap
朔月的专栏
01-22 9509
简介记录完了lift，再来看看另外两个经常被混淆的概念——map与flatmap。map的定义很容易理解，可以将它就是lift的“人性化”的延伸，但是flatmap就比较难以理解了，“扁平化map“是个啥？
RxJava基本流程和lift源码分析
热门推荐
大头鬼Bruce
11-30 2万+
首先感谢 扔物线 哥哥给的配图，实在太赞了。基本结构我们先来看一段最基本的代码，分析这段代码在RxJava中是如何实现的。Observable.OnSubscribe<String> onSubscriber1 = new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super
RxJava源码解析（三）背压+源码+同步异步+原理
Android_SE的博客
01-09 721
系列文章第三篇 承接上文：RXjava解析（二）我把RXjava的源码和这份面试都给你了，你还告诉我面不过拿不到offer? （顺手留下GitHub链接，需要获取相关面试等内容的可以自己去找） https://github.com/xiangjiana/Android-MS 更多完整项目下载。未完待续。源码。图文知识后续上传github。 可以点击关于我联系我获取 背压问题 背压是指在异步场...
RxJava源码分析
u014486880的博客
07-15 5023
最近因为实习的原因，又好长一段时间没写博客了。今天来个较简短的博客来强势回归哈哈。上篇博客写了RN的源码分析，出乎意料的就有两个出版社联系我要不要出书，可见RN的火热。本来也想写RN的，但因为最近实习接触了挺多Android的东东，还是想先总结总结先。RN就放后面啦。什么是RxJava接触RxJava也一段时间了，一直想写下关于它的文章，RxJava是用来实现异步框架的，类似于AsyncTask。这
Rxjava 源码分析
qx102的博客
08-30 803
主要介绍了Rxjava订阅流程，事件流向，线程切换等。
Rxjava 源码分析一
starlight_2012的博客
08-11 216
1、概述
RxJava 源码分析 （RxJava 1 ，RxJava 2）
u012610378的专栏
03-27 213
                      RxJava 1 源码分析准备工作：最好有观察者模式基础，本文采用的源码是 rxjava 版本是 1.0.0as倒入：compile 'io.reactivex:rxjava:1.0.0'一，示例代码：Subscription tSubscription = Observable.create(new Observable.OnSubscribe&lt;...
RxJava源码初步分析
幸福过饱和的专栏
05-14 2777
Demo分析响应式编程的概念现在火的一塌糊涂，各种RxXXX库层出不穷，虽然这些库的实现语言各不相同，但是原理都是一样的。我的理解是这些库主要都包含三个东西:Observable, OnSubscribe, Subscriber。阅读本文的读者必须懂的这些概念，初学者建议看下RxJava专题 上的文章再来看本文。我们就从源码层级来分析一下这中间的事件流，线程切换是怎么个原理。这里交代下本文分析的Rx
Scala之Lift框架实战
"Lift in Action 是一本由 Timothy Perrett 编著的书籍，专注于介绍基于 Scala 的 Lift Web 应用框架。这本书覆盖了 Lift 2.x 版本，旨在为读者提供一个简单而功能强大的 Web 开发框架。" 在 Scala 世界中，Lift ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值