RxJava源码（衍生RxLifecycle）

最新推荐文章于 2024-01-09 10:05:02 发布

milan-xiao-tiejiang

最新推荐文章于 2024-01-09 10:05:02 发布

阅读量214

点赞数

分类专栏： Android框架

本文链接：https://blog.csdn.net/MldXTieJiang/article/details/105122544

版权

Android框架专栏收录该内容

14 篇文章 0 订阅

订阅专栏

RxJava源码（衍生 RxLifecycle）

RxLifecycle 源码，这里先介绍 RxJava 中两个概念。

Hot Observable

无论有没有 Subscriber 订阅，事件始终都会发射。

Hot Observable 是共享数据的，对于 Hot Observable 的所有 subscriber ,他们会在同一时刻收到相同的数据。

Cold Observable

只有 Subscriber 订阅时，才开始发射数据流， Cold Observable 与订阅者只能是一对一的关系，即当有多个不同的订阅者时，消息是重新完整发送的。

常见的工厂方法提供的都是 Cold Observable。当你有多个 Subscriber 的时候，他们的事件是独立的。

Cold Observable 如何转换成 Hot Observable

publish()：将原始的 Observable 变成为 ConnectableObservable，ConnectableObservable 是当你订阅了它，它不会发射数据给你的。并且提供了 connect 方法，调用 connect 方法会开始发射数据给你。通过这种方式，可以选择 Observable 的发射时间。

Hot Observable 如何转换成 Cold Observable

refCount()：使 Connectable Observable 的行为类似于普通的 Observable，当第一个订阅者订阅这个 Observable 时，它连接到下层的可连接 Observable。它记录了订阅者的数量，直到最后一个观察者完成才断开与下层可连接 Observable 的连接。

了解几个操作符

compose 操作符：一般情况下可以配合 Transformer 使用，以实现将一种 Observable 转成另一种类型的 Observable。

take 操作符：只发出 Observable 发出的前 n 个 item。

skip 操作符：压制 Observable 发出的前 n 个 item。

map 操作符：通过对每个 item 应用函数来转换 Observable 发出的 item。

combineLatest操作符：Observable 发射的数据组装起来然后再发射出来。

Filter操作符：过滤。

takeUntil 操作符：在第二个 Observable 发射一个内容或终止后放弃第一个 Observable 发射的内容。

RxJava 的使用不当极有可能会导致内存泄漏，RxLifecycle 是对于 RxJava 这一问题进行的封装。

以 Activity 为例，父类的 BaseActivity 继承 RxActivity

open class BaseActivity : RxAppCompatActivity()

Activity 中使用 bindToLifecycle() 方法

        Observable.just("1")
                .compose(bindToLifecycle())
                .subscribe()

这样就完成了当前组件生命周期结束时，自动取消对 Observable 订阅。

当然除 bindToLifecycle 之外还有 bindUntilEvent()

    @CheckResult
    override fun <T> bindUntilEvent(event: ActivityEvent): LifecycleTransformer<T> {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event)
    }

    @CheckResult
    override fun <T> bindToLifecycle(): LifecycleTransformer<T> {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject)
    }

需要传入 ActivityEvent，对应有 CREATE、START、 RESUME、PAUSE、STOP、 DESTROY。这种指定在哪个生命周期方法调用时取消订阅。

public enum ActivityEvent {
    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY;

    private ActivityEvent() {
    }
}

源码解析

首先看下 RxActivity（我一般是自己去实现类似 RxActivity 中的逻辑的）

abstract class RxAppCompatActivity : AppCompatActivity, LifecycleProvider<ActivityEvent?>

实现 LifecycleProvider类，分别重写它里面的三个方法

   
    @Nonnull
    @CheckReturnValue
    Observable<E> lifecycle();

    @Nonnull
    @CheckReturnValue
    <T> LifecycleTransformer<T> bindUntilEvent(@Nonnull E event);

    @Nonnull
    @CheckReturnValue
    <T> LifecycleTransformer<T> bindToLifecycle();

也就是上文调用的方法。

在 RxAppCompatActivity 中创建 lifecycleSubject，它是 BehaviorSubject 对象，上文简单了解过了，这里不多说。

    private val lifecycleSubject = BehaviorSubject.create<ActivityEvent>()

lifecycle() 方法即返回这个对象，这边调用 lifecycleSubject.hide()；

hide() 方法比较陌生，它其实就是 Subject 强转成 Observable，但是仅仅是将 Subject 的 Observable 功能分享出去。

    //定义mUserViewStateSubject
    val mUserViewStateSubject: BehaviorSubject<Any> = BehaviorSubject.create()
    //hide()转换
    fun observeViewState(): Observable<Any> {
        return mUserViewStateSubject.hide()
    }
        //运行
        mUserViewStateSubject.onNext(1)
        (observable as BehaviorSubject).onNext(2)
        (observeViewState as BehaviorSubject).onNext(3)
        当运行到第三行时出错， Caused by: java.lang.ClassCastException: io.reactivex.internal.operators.observable.ObservableHide cannot be cast to io.reactivex.subjects.BehaviorSubject

余下两个函数调用的方法

    @CheckResult
    override fun <T> bindUntilEvent(event: ActivityEvent): LifecycleTransformer<T> {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event)
    }

    @CheckResult
    override fun <T> bindToLifecycle(): LifecycleTransformer<T> {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject)
    }

另外在 Activity 的生命周期中将 ActivityEvent 发射出去。

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleSubject.onNext(ActivityEvent.CREATE)
    }

    override fun onStart() {
        super.onStart()
        lifecycleSubject.onNext(ActivityEvent.START)
    }
 
    override fun onResume() {
        super.onResume()
        lifecycleSubject.onNext(ActivityEvent.RESUME)
    }
 
    override fun onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE)
        super.onPause()
    }
 
    override fun onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP)
        super.onStop()
    }
 
    override fun onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY)
        super.onDestroy()
    }

bindActivity 方法

    public static <T> LifecycleTransformer<T> bindActivity(@NonNull Observable<ActivityEvent> lifecycle) {
        return RxLifecycle.bind(lifecycle, ACTIVITY_LIFECYCLE);
    }

    private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE = new Function<ActivityEvent, ActivityEvent>() {
        public ActivityEvent apply(ActivityEvent lastEvent) throws Exception {
            switch(lastEvent) {
            case CREATE:
                return ActivityEvent.DESTROY;
            case START:
                return ActivityEvent.STOP;
            case RESUME:
                return ActivityEvent.PAUSE;
            case PAUSE:
                return ActivityEvent.STOP;
            case STOP:
                return ActivityEvent.DESTROY;
            case DESTROY:
                throw new OutsideLifecycleException("Cannot bind to Activity lifecycle when outside of it.");
            default:
                throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
            }
        }
    };

这里创建 Function<ActivityEvent, ActivityEvent>对象。

进入 RxLifecycle 的 bind

    public static <T, R> LifecycleTransformer<T> bind(@Nonnull Observable<R> lifecycle,
                                                      @Nonnull final Function<R, R> correspondingEvents) {
        checkNotNull(lifecycle, "lifecycle == null");
        checkNotNull(correspondingEvents, "correspondingEvents == null");
        return bind(takeUntilCorrespondingEvent(lifecycle.share(), correspondingEvents));
    }

主要看到有 bind() ，takeUntilCorrespondingEvent() 两个方法。

这边又有个陌生的操作符 share()，它又是什么呢？

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> share() {
        return publish().refCount();
    }

调用 publish().refCount()，上文说的用到了！！

takeUntilCorrespondingEvent()

    private static <R> Observable<Boolean> takeUntilCorrespondingEvent(final Observable<R> lifecycle,
                                                                       final Function<R, R> correspondingEvents) {
        return Observable.combineLatest(
            lifecycle.take(1).map(correspondingEvents),
            lifecycle.skip(1),
            new BiFunction<R, R, Boolean>() {
                @Override
                public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception {
                    return lifecycleEvent.equals(bindUntilEvent);
                }
            })
            .onErrorReturn(Functions.RESUME_FUNCTION)
            .filter(Functions.SHOULD_COMPLETE);
    }

    static final Predicate<Boolean> SHOULD_COMPLETE = new Predicate<Boolean>() {
        @Override
        public boolean test(Boolean shouldComplete) throws Exception {
            return shouldComplete;
        }
    };

比如我们在 oncreate 里面注册了订阅，take(1) 取出来就是 RxAppCompatActivity 中发来的ActivityEvent.CREATE，经过 map 转换则为 ActivityEvent.DESTROY的Observable。skip(1) 就是去除 ActivityEvent.CREATE。

而通过 combineLatest 的比较，发射出去的数据就是 false、false、fasle、false、true。

最后通过 filter 在 ActivityEvent.DESTROY时，即 onDestroy() 是发射出去数据。

随后的 bind() 生成一个 LifecycleTransformer 对象，并返回。

    public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }

LifecycleTransformer 是什么呢？

public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,
                                                      FlowableTransformer<T, T>,
                                                      SingleTransformer<T, T>,
                                                      MaybeTransformer<T, T>,
                                                      CompletableTransformer
{
    final Observable<?> observable;

    LifecycleTransformer(Observable<?> observable) {
        checkNotNull(observable, "observable == null");
        this.observable = observable;
    }

    @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);
    }

    @Override
    public Publisher<T> apply(Flowable<T> upstream) {
        return upstream.takeUntil(observable.toFlowable(BackpressureStrategy.LATEST));
    }

    @Override
    public SingleSource<T> apply(Single<T> upstream) {
        return upstream.takeUntil(observable.firstOrError());
    }

    @Override
    public MaybeSource<T> apply(Maybe<T> upstream) {
        return upstream.takeUntil(observable.firstElement());
    }

    @Override
    public CompletableSource apply(Completable upstream) {
        return Completable.ambArray(upstream, observable.flatMapCompletable(Functions.CANCEL_COMPLETABLE));
    }
}

实现了不同响应式数据类（Observable、Flowable等）的 Transformer 接口。比如我们是 Observable,那我们就会调用 LifecycleTransformer 里面实现的的 ObservableTransformer 对应的 apply 方法

这里用到了 takeUntil 操作符，之后在结合 compose，我们的 Observable 绑定在一起，如果这时候发送 true，我们的 Observable 就会取消订阅了。

            .compose(lifecycleProvider.bindToLifecycle())

学习 RxLifecycle 的过程中，更加体会到了对于观察者模式的使用，以及 RxJava 操作符的强大，各种操作符帮我们实现一些列的转换。

milan-xiao-tiejiang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava源码（衍生RxLifecycle）

Hot Observable无论有没有Subscriber订阅，事件始终都会发射。Hot Observable是共享数据的，对于Hot Observable的所有subscriber,他们会在同一时刻收到相同的数据。Cold Observable只有 Subscriber订阅时，才开始发射数据流， Cold Observable与订阅者只能是一对一的关系，即当有多个不...
复制链接

扫一扫

专栏目录