RxLifecycle详细解析

作者: Android架构 | 来源:发表于2019-04-29 20:31 被阅读11次

一、介绍

RxLifecycle目的：解决RxJava使用中的内存泄漏问题。

例如，当使用RxJava订阅并执行耗时任务后，当Activity被finish时，如果耗时任务还未完成，没有及时取消订阅，就会导致Activity无法被回收，从而引发内存泄漏。

为了解决这个问题，就产生了RxLifecycle，让RxJava变得有生命周期感知，使得其能及时取消订阅，避免出现内存泄漏问题。

二、使用

首先来介绍下RxLifecycle的使用。

1.添加依赖

  implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
  implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
  implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'

2.继承容器类

Activity/Fragment需要继承RxAppCompatActivity/RxFragment，主要支持如下几种容器类：

image

只需要在项目中针对base类的容器中继承实现对应的Rx类即可，这一步主要是对生命周期的回调事件进行监听。

3.绑定容器生命周期

以Activity为例，主要有如下两种方法：

bindUntilEvent(@NonNull ActivityEvent event)

bindToLifecycle()

针对Fragment也有同样的两种方法，只是方法名会有所不同。

下面详细介绍这两种方法的区别：

`bindUntilEvent`

该方法指定在哪个生命周期方法调用时取消订阅。

其中ActivityEvent是一个枚举类，对应于Activity的生命周期。

public enum ActivityEvent {

    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY

}

具体使用示例：

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose {
                    Log.i(TAG, "Unsubscribing subscription from onDestory()")
                }
                .compose(bindUntilEvent(ActivityEvent.DESTROY))
                .subscribe {
                    Log.i(TAG, "Started in onCreate(), running until in onDestroy(): $it")
                }
    }

指定在生命周期onDestory()时，取消订阅。

`bindToLifecycle`

在某个生命周期进行绑定，在对应的生命周期进行订阅解除。

具体使用示例：

override fun onResume() {
        super.onResume()
        Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose {
                    Log.i(TAG, "Unsubscribing subscription from onPause()")
                }
                .compose(bindToLifecycle())
                .subscribe {
                    Log.i(TAG, "Started in onResume(), running until in onPause(): $it")
                }
    }

在onResume()进行绑定订阅，则在onPause()进行解除订阅，生命周期是两两对应的。

三、原理解析

1.`compose`

首先来了解一下compose操作符。

compose(bindToLifecycle())
compose(bindUntilEvent(ActivityEvent.DESTROY))

如上所示，两种绑定生命周期的方式，都是通过compose操作符进行实现的。

compose一般情况下可以配合Transformer使用，以实现将一种类型的Observable转换成另一种类型的Observable，保证调用的链式结构。

那么接下来看该操作符在RxLifecycle中的应用，从bindToLifecycle和bindUntilEvent入手。

2.`BehaviorSubject`

public abstract class RxAppCompatActivity extends AppCompatActivity implements LifecycleProvider<ActivityEvent> {

    private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

    @Override
    @NonNull
    @CheckResult
    public final Observable<ActivityEvent> lifecycle() {
        return lifecycleSubject.hide();
    }

    @Override
    @NonNull
    @CheckResult
    public final <T> LifecycleTransformer<T> bindUntilEvent(@NonNull ActivityEvent event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }

    @Override
    @NonNull
    @CheckResult
    public final <T> LifecycleTransformer<T> bindToLifecycle() {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }

    @Override
    @CallSuper
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        lifecycleSubject.onNext(ActivityEvent.CREATE);
    }

    @Override
    @CallSuper
    protected void onStart() {
        super.onStart();
        lifecycleSubject.onNext(ActivityEvent.START);
    }

    @Override
    @CallSuper
    protected void onResume() {
        super.onResume();
        lifecycleSubject.onNext(ActivityEvent.RESUME);
    }

    @Override
    @CallSuper
    protected void onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE);
        super.onPause();
    }

    @Override
    @CallSuper
    protected void onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP);
        super.onStop();
    }

    @Override
    @CallSuper
    protected void onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY);
        super.onDestroy();
    }
}

RxAppCompatActivity中有一个关键对象BehaviorSubject

BehaviorSubject会发送离订阅最近的上一个值，没有上一个值的时候会发送默认值。如下图：

所以lifecycleSubject会根据绑定订阅的时期，不断发送接下来的生命周期事件ActivityEvent。

3.`LifecycleTransformer`

接下来继续看源码，bindToLifecycle和bindUntilEvent都返回了一个LifecycleTransformer对象，那么LifecycleTransformer到底有什么用？

@ParametersAreNonnullByDefault
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));
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (o == null || getClass() != o.getClass()) { return false; }

        LifecycleTransformer<?> that = (LifecycleTransformer<?>) o;

        return observable.equals(that.observable);
    }

    @Override
    public int hashCode() {
        return observable.hashCode();
    }

    @Override
    public String toString() {
        return "LifecycleTransformer{" +
            "observable=" + observable +
            '}';
    }
}

LifecycleTransformer实现了各种Transformer接口，能够将一个 Observable/Flowable/Single/Completable/Maybe 对象转换成另一个 Observable/Flowable/Single/Completable/Maybe对象。正好配合上文的compose操作符，使用在链式调用中。

4.`takeUntil`

接下来到了关键了，LifecycleTransformer到底把原来的Observable对象转换成了什么样子？

这就需要了解takeUntil操作符了！

当第二个Observable发射了一项数据或者终止时，丢弃原Observable发射的任何数据。所谓的第二个Observable，即传入takeUntil中的Observable对象。

理解了该操作符的作用，那么你可能就明白了，RxLifecycle就是通过监听第二个Observable发射的数据，来解除订阅。

那么这第二个Observable是谁？

不就是在创建LifecycleTransformer的时候传入构造函数中的嘛，那就来寻找一下什么时候创建的该对象即可。

从头开始捋一捋：

public final <T> LifecycleTransformer<T> bindUntilEvent(@NonNull ActivityEvent event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }

该方法返回了LifecycleTransformer对象，继续向下追溯。

public static <T, R> LifecycleTransformer<T> bindUntilEvent(@Nonnull final Observable<R> lifecycle,
                                                            @Nonnull final R event) {
    checkNotNull(lifecycle, "lifecycle == null");
    checkNotNull(event, "event == null");
    return bind(takeUntilEvent(lifecycle, event));
}

private static <R> Observable<R> takeUntilEvent(final Observable<R> lifecycle, final R event) {
    return lifecycle.filter(new Predicate<R>() {
        @Override
        public boolean test(R lifecycleEvent) throws Exception {
            return lifecycleEvent.equals(event);
        }
    });
}

继续追踪，马上接近真相。

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

在该方法中创建了该对象，并传入了一个Observable对象，通过上面方法即可知道该对象就是BehaviorSubject对象。

那么该对象在什么时候发送第一次数据呢？

这就要看上面的takeUntilEvent方法了。

关键在这一句lifecycleEvent.equals(event)，只有当BehaviorSubject发送的ActivityEvent的值等于解除绑定的生命周期时，才会发送第一次数据。那么当发送第一次数据时，根据上面的分析就会解除订阅的绑定。

那么针对bindToLifecycle方法，是进行怎样的操作，使得在对应的生命周期进行解除订阅呢？

还是继续看源码。

public final <T> LifecycleTransformer<T> bindToLifecycle() {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }

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

其中ACTIVITY_LIFECYCLE为：

private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE =
    new Function<ActivityEvent, ActivityEvent>() {
        @Override
        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");
            }
        }
    };

该函数的功能是会根据传入的生命周期事件，返回对应的生命周期，如CREATE→DESTROY。看来通过该函数就可以实现在对应生命周期解绑了。

不过还需要一系列操作符的协助，继续看源码。

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));
    }

    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);
    }

详细看一下takeUntilCorrespondingEvent方法。

5.`take`

首先看一下take操作符，很简单。

take(int)用一个整数n作为一个参数，只发射前面的n项，如下图：

那么对应lifecycle.take(1).map(correspondingEvents)，即获取发送的第一个生命周期事件，再通过上面对应的函数，转换为响应的生命周期。如果在onCreate中进行绑定，那么第一个发送的就是CREATE，返回的就是对应的DESTORY。

6.`skip`

skip(int)忽略Observable发射的前n项数据

lifecycle.skip(1)，如果在onCreate中进行绑定，那么剩余的就是START，RESUME，PAUSE，STOP，DESTROY

7. `combineLatest`

最后还需要一个关键的操作符combineLatest，来完成对应生命周期的解除订阅。

combineLatest操作符可以将2~9个Observable发射的数据组装起来然后再发射出来。不过还有两个前提：

所有的Observable都发射过数据。
满足上面条件的时候任何一个Observable发射一个数据，就将所有Observable最新发射的数据按照提供的函数组装起来发射出去。

具体示例，如下图所示：

按照第三个参数的函数，将lifecycle.take(1).map(correspondingEvents)和lifecycle.skip(1)，进行combine

new BiFunction<R, R, Boolean>() {
                @Override
                public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception {
                    return lifecycleEvent.equals(bindUntilEvent);
                }
            }

那么结果是

false,false,false,false,true

之后的onErrorReturn和filter是对异常的处理和判断是否应该结束订阅：

//异常处理
static final Function<Throwable, Boolean> RESUME_FUNCTION = new Function<Throwable, Boolean>() {
        @Override
        public Boolean apply(Throwable throwable) throws Exception {
            if (throwable instanceof OutsideLifecycleException) {
                return true;
            }

            //noinspection ThrowableResultOfMethodCallIgnored
            Exceptions.propagate(throwable);
            return false;
        }
    };
    //是否应该取消订阅，依赖于上游的boolean
    static final Predicate<Boolean> SHOULD_COMPLETE = new Predicate<Boolean>() {
        @Override
        public boolean test(Boolean shouldComplete) throws Exception {
            return shouldComplete;
        }
    };

所以，按照上面的例子，如果在onCreate()方法中进行绑定，那么在onDestory()方法中就会对应的解除订阅。

四、总结

通过上面的分析，可以了解RxLifecycle的使用以及原理。

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

自己是从事了七年开发的Android工程师，不少人私下问我，2019年Android进阶该怎么学，方法有没有？

没错，年初我花了一个多月的时间整理出来的学习资料，希望能帮助那些想进阶提升Android开发，却又不知道怎么进阶学习的朋友。【包括高级UI、性能优化、架构师课程、NDK、Kotlin、混合式开发（ReactNative+Weex）、Flutter等架构技术资料】，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。

资料获取方式：加入Android架构交流QQ群聊：513088520 ，进群即领取资料！！！

点击链接加入群聊【Android移动架构总群】：加入群聊

资料大全

RxLifecycle详细解析

一、介绍

二、使用

1.添加依赖

2.继承容器类

3.绑定容器生命周期

`bindUntilEvent`

`bindToLifecycle`

三、原理解析

1.`compose`

2.`BehaviorSubject`

3.`LifecycleTransformer`

4.`takeUntil`

5.`take`

6.`skip`

7. `combineLatest`

四、总结

自己是从事了七年开发的Android工程师，不少人私下问我，2019年Android进阶该怎么学，方法有没有？

资料获取方式：加入Android架构交流QQ群聊：513088520 ，进群即领取资料！！！

点击链接加入群聊【Android移动架构总群】：加入群聊

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android开发

程序员

Android技术知识

Android开发经验谈

Android开发

程序园

RxLifecycle详细解析

一、介绍

二、使用

1.添加依赖

2.继承容器类

3.绑定容器生命周期

bindUntilEvent

bindToLifecycle

三、原理解析

1.compose

2.BehaviorSubject

3.LifecycleTransformer

4.takeUntil

5.take

6.skip

7. combineLatest

四、总结

自己是从事了七年开发的Android工程师，不少人私下问我，2019年Android进阶该怎么学，方法有没有？

资料获取方式：加入Android架构交流QQ群聊：513088520 ，进群即领取资料！！！

点击链接加入群聊【Android移动架构总群】：加入群聊

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android开发

程序员

Android技术知识

Android开发经验谈

Android开发

程序园

`bindUntilEvent`

`bindToLifecycle`

1.`compose`

2.`BehaviorSubject`

3.`LifecycleTransformer`

4.`takeUntil`

5.`take`

6.`skip`

7. `combineLatest`