Android RxJava生命周期管理解决方案整理

最新推荐文章于 2024-04-21 12:47:24 发布

残风乱了温柔

最新推荐文章于 2024-04-21 12:47:24 发布

阅读量2.1k

点赞数 1

分类专栏： # 开源框架

本文链接：https://blog.csdn.net/fitaotao/article/details/117522260

版权

开源框架专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、为什么要做生命周期管理？

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        //TODO
    }
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
    @Override
    public void accept(String str) throws Exception {
        
    }
});

这样就是一个简单的异步处理，但是如果只是这样使用肯定是不行，因为在 Android 开发过程中，如果在进行耗时操作的时候，操作还没有结束，这个时候退出的当前 Activity，这个时候，这段代码的处理并不会因为 Activity 的退出而结束，就会导致内存泄漏等问题，严重的时候甚至会导致 APP 闪退。

二、如何管理生命周期？

1、使用CompositeDisposable 这个类，手动实现对 RxJava 的管理

原理：每次使用 RxJava，都将其生成的 Disposable 对象添加到 CompositeDisposable 对象中，并在每个界面结束(onDestroy)的时候，调用 CompositeDisposable 对象的 clear()方法取消事件。

实现过程：1.实现一个统一管理的基准类

public class CommonComposite {

    private CompositeDisposable mCompositeDisposable;

    public void addDisposable(Disposable disposable) {
        if (mCompositeDisposable == null || mCompositeDisposable.isDisposed()) {
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(disposable);
    }

    public void unDisposable() {
        if (mCompositeDisposable != null) {
            mCompositeDisposable.dispose();
        }
    }
}

2.在每次使用RxJava时，在最后的订阅subscribe之前，统一添加doOnSubscribe()方法，并在里面调用上面的addDisposable()，如下：

RetrofitClient.get()
        .invoke(CommandId.CASH_OUT_APPLY_LIST, params.toString())
        .doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                addDisposable(disposable);
            }
        })
        .subscribe(new CommonObserver<CashOutApplyList>() {
            @Override
            public void onSuccess(CashOutApplyList data) {
                mView.updateCashOutApplyList(data.getRows());
            }

            @Override
            public void onError(String msg, String code) {
                mView.updateCashOutApplyList(msg);
            }
        });

3.在页面销毁的回调方法中(如onDestroy)中调用unDisposable()进行取消事件订阅

@Override
protected void onDestroy() {
    if( mPresenter!=null){
        mPresenter.unsubscribe();
    }
    super.onDestroy();
}
@Override
public void unsubscribe() {
    unDisposable();
}

2、使用RxLifecycle

Github：https://github.com/trello/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，主要支持如下几种容器类：

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

3.绑定容器生命周期

以Activity为例，主要有如下两种方法(Fragment也有同样的两种方法，只是方法名会有所不同)：

bindUntilEvent(@NonNull ActivityEvent event) 

bindToLifecycle()

（1）bindUntilEvent(@NonNull ActivityEvent event)

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

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

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

使用如下：指定在生命周期onDestory()时，取消订阅

@SuppressLint("AutoDispose")
    private void test() {
      Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .compose(bindUntilEvent(ActivityEvent.DESTROY))//指定在生命周期onDestory()时，取消订阅
                .subscribe(new Observer<Long>() {

                    Disposable disposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                        disposable = d;
                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                        Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "=========");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "=======" + "onError：" + "=========");
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "=======" + "onComplete：" + "=========");
                    }
                });
    }

运行结果如下：

（2）使用bindToLifecycle()

//在某个生命周期进行绑定，在对应的生命周期进行订阅解除。具体的对应关系如下：

使用如下：在生命周期onStart()时进行绑定(就是test2()方法放在onStart()中)，在onStop()时取消

@SuppressLint("AutoDispose")
    private void test2() {
        Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .compose(bindToLifecycle())//在某个生命周期进行绑定，在对应的生命周期进行订阅解除。如在onResume()里调用test2()进行绑定订阅，则在onPause()进行解除订阅，生命周期是两两对应的。
                .subscribe(new Observer<Long>() {

                    Disposable disposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                        disposable = d;
                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                        Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "========="); 
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "=======" + "onError：" + "=========");
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "=======" + "onComplete：" + "=========");
                    }
                });

运行结果如下：

原理分析：

主要就是：compose、BehaviorSubject、LifecycleTransformer、takeUntil、take、skip、combineLatest这几部分；详细参考 RxLifecycle的使用及原理分析

它的设计思路：

1.在Activity中，定义一个Observable（Subject），在不同的生命周期发射不同的事件；

2.通过compose操作符（内部实际上还是依赖takeUntil操作符），定义了上游数据，当其接收到Subject的特定事件时，取消订阅；

3.Subject的特定事件并非是ActivityEvent，而是简单的boolean，它已经内部通过combineLast操作符进行了对应的转化。

实际上，Subject和ActivityEvent对RxLifecycle的使用者来讲，是对应隐藏的。我们只需要调用它提供给我们的API,而内部的实现者我们无需考虑，但是也只有去阅读和理解了它的思想，我们才能更好的选择使用这个库

3、使用RxAutoDispose（分引入LifeCycle和不引入）

Github：https://github.com/uber/AutoDispose

实现过程：1.添加依赖

implementation 'com.uber.autodispose:autodispose:1.3.0'
implementation 'com.uber.autodispose:autodispose-android-archcomponents:1.3.0'

2.在代码中使用（两种使用方式）

//在Activity或Fragment中使用
.as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))//方式一，自动绑定，在哪里注册，那么就在它的对立时期解除绑定
.as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this, Lifecycle.Event.ON_DESTROY)))//方式二：指定解除绑定周期

private void test() {
    Observable.interval(0, 1, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                    Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                    Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                }
            })
            //AutoDispose在被订阅时，获取到Activity当前的生命周期，并找到对应需要结束订阅的生命周期事件
            .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))//方式一，自动绑定，在哪里注册，那么就在它的对立时期解除绑定
            .subscribe(new Observer<Long>() {

                Disposable disposable;

                @Override
                public void onSubscribe(Disposable d) {
                    Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                    disposable = d;
                }

                @Override
                public void onNext(Long aLong) {
                    Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                    Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "=========");
                    textview.setText(String.valueOf(aLong));
                    if (aLong >= 10) {
                        disposable.dispose();
                        Log.e(TAG, "=======" + "dispose" + "=========");//这里会落后于doOnDispose执行
                    }
                }

                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, "=======" + "onError：" + "=========");
                }

                @Override
                public void onComplete() {
                    Log.e(TAG, "=======" + "onComplete：" + "=========");
                }
            });
}

原理分析：

as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this))

（1）参数this：

就是Activity本身，当然它也可以是Fragment，这个参数对象只有一个要求，就是必须实现LifecycleOwner接口。LifecycleOwner接口是Google Android官方架构组件:Lifecycle的一个重要组件，在androidx中，ComponentActivity实现了这个接口，实现了这个接口的对象都拥有生命周期（Lifecycle）。这意味着，只要是实现了LifecycleOwner的类，都可以作为参数传给AutoDispose，用以控制Observable和组件生命周期的绑定。

（2）如何实现生命周期的绑定

参考RxLifecycle的原理：

1.在Activity中，定义一个Observable（Subject），在不同的生命周期发射不同的事件； 2.通过compose操作符（内部实际上还是依赖takeUntil操作符），定义了上游数据，当其接收到Subject的特定事件时，取消订阅； 3.Subject的特定事件并非是ActivityEvent，而是简单的boolean，它已经内部通过combineLast操作符进行了对应的转化

AutoDispose获取了Activity(LifecycleOwner)对象，并定义了一个新的Observable，在Activity的不同生命周期中，发射对应的事件。

和RxLifecycle很类似的是，AutoDispose在被订阅时，获取到Activity当前的生命周期，并找到对应需要结束订阅的生命周期事件：

private static final CorrespondingEventsFunction<Lifecycle.Event> DEFAULT_CORRESPONDING_EVENTS =
    lastEvent -> {
      switch (lastEvent) {
        case ON_CREATE:
          return Lifecycle.Event.ON_DESTROY;
        case ON_START:
          return Lifecycle.Event.ON_STOP;
        case ON_RESUME:
          return Lifecycle.Event.ON_PAUSE;
        case ON_PAUSE:
          return Lifecycle.Event.ON_STOP;
        case ON_STOP:
        case ON_DESTROY:
        default:
          throw new LifecycleEndedException("Lifecycle has ended! Last event was " + lastEvent);
      }
    };

也就是说，在我们的ObservableA订阅时，就已经知道了自己在Activity的哪个生命周期让AutoDispose内部自定义的ObservableB自动发射事件，ObservableA监听到这个事件时且未dispose，解除订阅避免内存泄漏。

毕竟内存泄漏是少数，更大的可能是ObservableA早就执行完任务dispose了，因此ObservableB实际上就是一个Maybe，类似于

ObservableA.takeUntil( Maybe< true > )

核心代码：

public static <E> CompletableSource resolveScopeFromLifecycle(
    Observable<E> lifecycle, final E endEvent, @Nullable final Comparator<E> comparator) {
  Predicate<E> equalityPredicate;
  if (comparator != null) {
    equalityPredicate = e -> comparator.compare(e, endEvent) >= 0;
  } else {
    equalityPredicate = e -> e.equals(endEvent);
  }
  return lifecycle.skip(1).takeUntil(equalityPredicate).ignoreElements();
}

（3）as方法执行后生成了一个什么？

as方法内部生成了一个AutoDisposeConverter对象，类似于compose,不同的是，Observable通过compose生成的对象还是Observable，但as方法生成的则是一个新的对象：

public final <R> R as(@NonNull ObservableConverter<T, ? extends R> converter)

实际上，抛开复杂的细节，AutoDispose最终将原来的Observable，生成了一个新的AutoDisposeObservable对象, 在执行订阅时，也生成了一个新的AutoDisposingObserverImpl对象

（4）AutoDispose和RxLifecycle的区别

原理相似，但是RxLifecycle有如下局限性:

1、需要继承父类（RxActivity / RxFragment等）

2、如何处处绑定生命周期？

简单的例子，我的RecyclerView的Adapter中订阅了Observable，亦或者，在MVP的架构或者 MVVM架构中，我的presenter或者我的viewModel无法直接获取RxActivity的引用(作为View 层，更应该抽象为一个接口与Presenter进行交互)。这意味着，想要进行Observable的生命周期绑定，在RecyclerView的Adapter中,我必须要通过将Activity作为依赖，注入到Adapter中： new ListAdapter(RxActivity activity); 而对于Presenter，我需要对View抽象接口进行instanceof 的判断：

if (view instanceof RxActivity) {

return bindToLifecycle((RxActivity) view);

}

4、如何把AutoDispose添加到目前的Android项目中

（以MVP架构为例）

方式一：

（1）封装Util类

static class RxAutoDisposeUtils {

    private RxAutoDisposeUtils() {
    }

    public static <T> AutoDisposeConverter<T> bindLifecycle(LifecycleOwner lifecycleOwner) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner));
    }

    public static <T> AutoDisposeConverter<T> bindLifecycle(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, event));
    }

    public static <T> AutoDisposeConverter<T> bindDestroyLifecycle(LifecycleOwner lifecycleOwner) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, Lifecycle.Event.ON_DESTROY));
    }
}

（2）在BaseActivity/BaseFragment中添加代码

只要持有LifecycleOwner对象，Observable都可以通过RxLifecycleUtils.bindLifecycle(LifecycleOwner)进行绑定

fun <T> bindLifecycle(): AutoDisposeConverter<T> {
        return AutoDispose.autoDisposable<T>(AndroidLifecycleScopeProvider.from(lifecycle))

//        return AutoDispose.autoDisposable<T>(
//            AndroidLifecycleScopeProvider.from(
//                lifecycleOwner,
//                Lifecycle.Event.ON_DESTROY
//            )
//        )
    }

（3）在任何BaseActivity的实现类中，我们都可以通过下述代码实现Observable的生命周期绑定

Observable.interval(0, 1, TimeUnit.SECONDS)
        .as(bindLifecycle())
        .subscribe()

（4）在Presenter中通过持有Activity的对象，达到Observable生命周期的绑定（类似RxLifecycle的使用）

public interface BaseView {
    <T> LifecycleTransformer<T> getActivityLifecycleProvider();
    LifecycleOwner getLifecycleOwner();
}

public class RxJavaContract {
    interface View extends BaseView {
        void onNetRequest();
    }
    interface Presenter extends BasePresenter {
        void netRequest();
    }
}

//在BaseActivity中实现如下方法
open fun <T> getActivityLifecycleProvider(): LifecycleTransformer<T> {
//        return bindToLifecycle() //可以绑定Activity生命周期
        return bindUntilEvent(ActivityEvent.DESTROY);//可以绑定Activity生命周期
    }

    fun getLifecycleOwner(): LifecycleOwner {
        return this
    }

public class RxJavaPresenter implements RxJavaContract.Presenter {
    private RxJavaContract.View mView;
    Observable.interval(1, TimeUnit.SECONDS)
            .compose(mView.getActivityLifecycleProvider())
            .subscribe()
}

方式二：使用Google官方Lifecycle组件

（1）首先让我们的IPresenter接口实现LifecycleObserver接口

//实现了 LifecycleObserver 接口的类可以和实现了 LifecycleOwner 接口的类无缝工作
//，因为 LifecycleOwner 可以提供一个 Lifecycle 对象，而 LifecycleObserver 就正
//需要对这个 Lifecycle 对象进行监听呢。 LifecycleOwner 是从特定的类（比如
// Activity 或者 Fragment 等）中抽象出来的Lifecycle 的持有者
interface IPresenter : LifecycleObserver {

    //使用Google官方Lifecycle组件
    // 使用注解  @OnLifecycleEvent 来表明该方法需要监听指定的生命周期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(@NotNull owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(@NotNull owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onLifecycleChanged(@NotNull owner: LifecycleOwner, @NotNull event: Lifecycle.Event)
}

（2）然后在BasePresenter中管理LifecycleOwner

abstract class BaseNewPresenter :
    IPresenter {

    private lateinit var lifecycleOwner: LifecycleOwner

    override fun onCreate(owner: LifecycleOwner) {
        Log.e("LifecycleOwner", "=======" + "onCreate：" + "=========")
        this.lifecycleOwner = owner
    }

    override fun onDestroy(owner: LifecycleOwner) {

    }

    override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {

    }

    fun <T> bindLifecycle(): AutoDisposeConverter<T> {
        return AutoDispose.autoDisposable<T>(AndroidLifecycleScopeProvider.from(lifecycleOwner))

//        return AutoDispose.autoDisposable<T>(
//            AndroidLifecycleScopeProvider.from(
//                lifecycleOwner,
//                Lifecycle.Event.ON_DESTROY
//            )
//        )
    }
}

（3）最后在Activity中添加Presenter为观察者，观察Activity的生命周期

abstract class BaseNewMvpActivity<P : IPresenter> : BaseNewActivity(){
    lateinit var presenter: P

    override fun onCreate(savedInstanceState: Bundle?) {
        presenter = createPresenter()
        //这一行，如此每当Activity发生了对应的生命周期改变，Presenter就会执行
        //对应事件注解的方法
        lifecycle.addObserver(presenter)
        super.onCreate(savedInstanceState)
    }
}

（4）Presenter中的使用

public class RxAutoDisposePresenter extends BaseNewPresenter implements RxAutoDisposeContract.Presenter {

    private RxAutoDisposeContract.View mView;
    private Context mContext;
    private String TAG = RxAutoDisposePresenter.class.getSimpleName();

    public RxAutoDisposePresenter(Context context, RxAutoDisposeContract.View view) {
        this.mContext = context;
        this.mView = view;
    }

    @Override
    public void netRequest() {
        Observable.interval(0, 1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .as(bindLifecycle())//方式二：指定解除绑定周期
                .subscribe(new BaseObserver<Long>() {
                    @Override
                    public void onSuccess(Long data) {
                        Log.e(TAG, "=======" + "onSuccess：" + data + "=========");
                        mView.onNetRequest(data);
                    }

                    @Override
                    public void onError(String msg, String code) {
                        mView.onNetRequest(Long.parseLong(code));
                    }
                });
    }
}

我们即使在Presenter中，也能任意使用myObservable.as(bindLifecycle()) 方法了，和第一种方式相比，更加灵活。

残风乱了温柔

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
2
评论
Android RxJava生命周期管理解决方案整理

一、为什么要做生命周期管理？Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(ObservableEmitter<String> emitter) throws Exception { //TODO } }) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .
复制链接

扫一扫