RxJava 学习笔记4 - lift()

fun start() {
    Observable.create<String> {
        println("onSubscribe")
        it.onNext("1")
    }.lift<Int> { subscriber ->
        println("lift")
        //感觉像是自己手动实现 map
        return@lift object : Subscriber<String>() {
            override fun onNext(t: String?) {
                //不同于 map() 的是,转换结果是手动 onNext() 而不是直接返回,有更高的灵活性
                println("lift-onNext")
                subscriber.onNext(t!!.toInt())
            }

            override fun onCompleted() {
                subscriber.onCompleted()
            }

            override fun onError(e: Throwable?) {
                subscriber.onError(e)
            }
        }
    }.subscribe {
        println(it)
    }
    /* 中心思想:
    lift() 就是 Subscriber 封装的抽象层,在上面代码中是我们手动实现了 Subscriber 的封装。
    对于 RxJava 的链式编程内部方法调用流程可以大致理解为
    1、【走 RxJava 表层方法】 一行一行走我们的代码,从上到下 create -> lift RxJava 内部做创建对象(封装)操作,执行完毕时 OnSubscribe 的引用树是下层嵌套上层    2、【走 RxJava 内部call】 我们的代码走到 subscribe()subscribe() 中调用到 onSubscribe  call() RxJava 内部开始从逐个调用 OnSubscribe  call()。 看起来就是从下往上的执行 call() ”
            由于 call 中会创建 Subscriber,执行完毕时 Subscriber 的引用树是上层嵌套下层    3、【走我们的 onNext  call 的代码走到 createcreate() 中调用到我们的 create代码块:开始由 我们调用onNext() 来逐个执行 Subscriber  onNext()。看起来就是从上往下执行 onNext()”
    有图 RxJava - 链式编程大致流程
     */
}

/*
~ 经过对 map() 的分析,感觉已经轻车熟路了。
先看 lift() 源码

1 // 熟悉的 create ,那么重点就是 OnSubscribeLift  Operator
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
}

2 OnSubscribeLift 源码出奇的少
@Override
public void call(Subscriber<? super R> o) { // o == SafeSubscriber
    try {
        Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o); //  operator.call(subscriber) ,结合我们的RxJava调用流程
        try { // 就是走我们的 lift代码块 , st 就是我们在 lift代码块 中创建的那个 Subscriber
            // new Subscriber created and being subscribed with so 'onStart' it
            st.onStart();
            parent.call(st); // onSubscribe.call() = 走 我们创建的 onSubscribe
        } catch (Throwable e) {
            // localized capture of errors rather than it skipping all operators
            // and ending up in the try/catch of the subscribe method which then
            // prevents onErrorResumeNext and other similar approaches to error handling
            Exceptions.throwIfFatal(e);
            st.onError(e);
        }
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // if the lift function failed all we can do is pass the error to the final Subscriber
        // as we don't have the operator available to us
        o.onError(e);
    }
}

看完 《1》《2》 后就知道了 OnSubscribeLift 只是直接调用我们的 lift代码块 来得到我们封装后的 Subscriber 而已,并没有像 map 那样主动封装 Subscriber ,复杂程度很低
它也并不像 map 那样有双层封装来让顺序正序执行,所以 lift代码块 会被先执行。 但我们封装的 Subscriber 会符合顺序,正序执行

由这种简单的结构可以发现,这种简单的结构很适合作为抽象层,让子层去扩展。随意定义 Operator 的实现类就能增加对 Subscriber 的封装操作

*/

 * 说的上一层下一层,指的是:RxJava 操作运算符的 上一个运算符,下一个运算符。
 * .create{ ... } // subscribe 的上一层
 * .subscribe{ ... } // create 的下一层
 */
class MyObservable<T> private constructor(val onSubscribe: Observable.OnSubscribe<T>) {

    fun subscribe(f: Action1<T>) {

        var action: Subscriber<T> = MyActionSubscriber(f,
                Action1 { throwable -> throw throwable },
                Action0 {})

        if (action !is MySafeSubscriber)
            action = MySafeSubscriber(action)

        try {
            this.onSubscribe.call(action)
        } catch (e: Exception) {
            //SafeSubscriber相同的异常处理逻辑: 代码异常 -> onError()  RxJava使用异常 -> 抛出崩溃
        }
    }

    fun unsafeSubscribe(subscriber: Subscriber<T>?) {
        try {
            this.onSubscribe.call(subscriber)
        } catch (e: Exception) {
            //SafeSubscriber相同的异常处理逻辑: 代码异常 -> onError()  RxJava使用异常 -> 抛出崩溃
        }
    }

    fun <R> map(mapBlock: Func1<T, R>): MyObservable<R> {
        return MyObservable(MyOnSubscribeMap(this, mapBlock))
    }

    // 泛型 T -> R 当前类型为 T 转换为 R ,要注意 Operator 的泛型是 反着声明的,在其注解中也有提到。
    // 传入 Operator  Subscriber 是下层 call() 中封装好的 Subscriber,类型是下层的 R 类型
    // Operator.call() 得到的 Subscriber 是要传给上层的 parent.call() 是内部创建的 Subscriber ,类型是 T
    fun <R> lift(operator: Observable.Operator<R, T>): MyObservable<R> {
        return create(MyOnSubscribeLift(this.onSubscribe, operator))
    }

    companion object {

        fun <T> create(onSubscribe: Observable.OnSubscribe<T>): MyObservable<T> {
            return MyObservable(onSubscribe)
        }

        fun <T> create(array: Array<T>): MyObservable<T> {
            return MyObservable(MyOnSubscribeFromArray(array))
        }
    }
}

///
// OnSubscribe 的扩展
///

/** 数组型 OnSubscribe */
class MyOnSubscribeFromArray<T>(val array: Array<T>) : Observable.OnSubscribe<T> {
    var child: Subscriber<in T>? = null

    override fun call(t: Subscriber<in T>?) {
        child = t
        fastPath()
    }

    //实际执行我们的代码
    private fun fastPath() {
        val child = this.child // child == SafeSubscriber
        for (t in array) {
            if (child?.isUnsubscribed == true) { // 检测有效性
                return
            }

            child?.onNext(t) // 执行我们的代码
        }

        if (child?.isUnsubscribed == true) {
            return
        }
        child?.onCompleted() // 最后走一遍 onCompleted()
    }

    //private fun slowPath() // 被我们忽略的方法,与线程有关
}

/** 类型转换 T -> R */ // 封装 T 类型的 Observable,自身却是 R 类型,由此进行转换。 call() 时实际走的也是 R 类型
class MyOnSubscribeMap<T, R>(val source: MyObservable<T>, val transformer: Func1<T, R>) : Observable.OnSubscribe<R> {
    override fun call(subscriber: Subscriber<in R>?) {
        val parent = MyMapSubscriber(subscriber, transformer)
        source.unsafeSubscribe(parent)
    }
}

/** 抽象化(Subscriber 封装)*/ // T:当前类型  R:转换后类型 = 上层 Observable.onSubscribe 类型
class MyOnSubscribeLift<T, R>(val parent: Observable.OnSubscribe<R>, val operator: Observable.Operator<T, R>) : Observable.OnSubscribe<T> {
    override fun call(t: Subscriber<in T>?) {
        val newSubscriber = operator.call(t) // 类型转换 T -> R
        parent.call(newSubscriber)
    }
}

///
// Subscriber 的扩展
///

/** 扩展 onError  onCompleted */
class MyActionSubscriber<T>(val onNext: Action1<in T>, val onError: Action1<Throwable>, val onCompleted: Action0) : Subscriber<T>() {

    override fun onNext(t: T) {
        onNext.call(t)
    }

    override fun onError(e: Throwable) {
        onError.call(e)
    }

    override fun onCompleted() {
        onCompleted.call()
    }
}

/** 增加对异常的处理*/
class MySafeSubscriber<T>(val actual: Subscriber<in T>) : Subscriber<T>(actual, true) {
    var done: Boolean = false

    override fun onNext(t: T) {
        try {
            if (!done)
                actual.onNext(t)
        } catch (e: Throwable) {
            Exceptions.throwIfFatal(e)
            onError(e)
        }
    }

    override fun onCompleted() {
        if (!done) {
            done = true
            try {
                actual.onCompleted()
            } catch (e: Throwable) {
                Exceptions.throwIfFatal(e)
                try {
                    unsubscribe()
                } catch (e: Throwable) {
                    RxJavaHooks.onError(e)
                }
            }
        }
    }

    //若异常在 Exceptions.throwIfFatal(e) 中抛出,即 RxJava 操作异常会崩溃
    override fun onError(e: Throwable?) {
        Exceptions.throwIfFatal(e)
        if (!done) {
            done = true
            try {
                actual.onError(e)
            } catch (e: Throwable) {
                try {
                    unsubscribe()
                } catch (e: Throwable) {
                    RxJavaHooks.onError(e)
                }
            }
        }
    }
}

/**  OnSubscriberMap 创建,用于正向执行 mapBlock */ // T -> R 自身是 T 类型,所以 onNext() 传入的是 T ,但内部的 subscriber  R 类型,所以到下一层就传的是 R 类型
class MyMapSubscriber<T, R>(val actual: Subscriber<in R>?, val mapper: Func1<T, R>) : Subscriber<T>() {

    override fun onNext(t: T) {
        val result = mapper.call(t)
        actual?.onNext(result)
    }

    override fun onCompleted() {
        actual?.onCompleted()
    }

    override fun onError(e: Throwable?) {
        actual?.onError(e)
    }
}

fun useDemo() {
    MyObservable
            .create<Int>(Observable.OnSubscribe {
                println("onSubscribe")
                it.onNext(5)
            }).lift<String>(Observable.Operator { subscriber ->
                // subscriber = 下层 call() 中封装好的 SafeSubscriber<String>
                println("lift")
                return@Operator object : Subscriber<Int>() { // 上层要拿走 call()  Subscriber<Int>
                    override fun onNext(t: Int?) {
                        println("lift-onNext")
                        subscriber.onNext("subscriber")
                    }

                    override fun onCompleted() {
                        subscriber.onCompleted()
                    }

                    override fun onError(e: Throwable?) {
                        subscriber.onError(e)
                    }
                }
            }).subscribe(Action1 { t ->
                println(t)
            })
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值