关于android:Android-解决RxJava导致内存泄露的RxLifecycle

41次阅读

共计 6638 个字符，预计需要花费 17 分钟才能阅读完成。

Android 解决 RxJava 导致内存泄露的 RxLifecycle

一：前景
在应用 RxJava 的时候，如果没有及时的解除订阅，在退出 activity 的时候，异步线程还在执行。对 Activity 的还在援用，此时就会产生内存泄露。
RxLifecycle 就是为了解决 rxjava 导致的内存透露而产生的。
1. 增加依赖

//RxLifecycle
    implementation 'com.trello.rxlifecycle3:rxlifecycle:3.1.0'
    implementation 'com.trello.rxlifecycle3:rxlifecycle-components:3.1.0'

2.Activity 和 Fragment
Activity
RxAppCompatActivity、RxActivity、RxFragmentActivity
Fragment
RxFragment、RxDialogFragment、RxPreferenceFragment、RxAppCompatDialogFragment

二：RxLifecycle 应用
1.bindUntilEvent（ActivityEvent e）

public class TenActivity extends RxAppCompatActivity implements View.OnClickListener {
    private Button btn;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ten);
        btn=findViewById(R.id.btn);
        btn.setOnClickListener(this::onClick);
    }
   @Override
    public void onClick(View v) {
    // 应用 RxJava，定时每 3 秒打印
    //compose()是惟一一个可能从数据流中失去原始 Observable 的操作符，所以，那些须要对整个数据流产生作用的操作（比方，subscribeOn()和 observeOn()）须要应用 compose()来实现。相较而言，如果在 flatMap()中应用 subscribeOn()或者 observeOn()，那么它仅仅对在 flatMap()中创立的 Observable 起作用，而不会对剩下的流产生影响
        Observable.interval(3, TimeUnit.SECONDS)
                .compose(bindUntilEvent(ActivityEvent.DESTROY))// 通过 compose 绑定 RxLifecycle 的 Activity 的生命周期
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {Log.d("aaa", String.valueOf(aLong));
                    }
                });

    }

    @Override
    protected void onDestroy() {super.onDestroy();
        Log.d("aaa", "onDestory()");
    }
    }
    
    // 打印后果
           aaa: 0
           aaa: 1
           aaa: 2
           aaa: 3
           aaa: onDestory()

以上代码的意思是说，以后 Activity 执行到 onDestroy 时，Observable 勾销订阅
bindUntilEvent 前面的参数决定 Observable 什么时候被勾销
ActivityEvent 对应的是 Activity 生命周期办法

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

    private ActivityEvent() {}
}


2.bindToLifecycle()应用

// 咱们在 Activity 在 onResume()生命周期里点击执行 RxJava 每 3 秒打印
 Observable.interval(3, TimeUnit.SECONDS)
                .compose(bindToLifecycle())// 应用第二种形式 bindToLifecycle 绑定生命周期，没有传入去生命周期，后果是在 onPause 下解除绑定这是为什么呢，须要源码剖析
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {Log.d("aaa", String.valueOf(aLong));
                    }
                });
                
     // 后果：aaa: 0
       aaa: 1
       aaa: 2
       aaa: onPause()

源码：

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

源码意思：
如果 Observable 在 onCreate 执行，那么当执行到 onDestroy 时勾销订阅；
如果 Observable 在 onStart 执行，那么当执行到 onStop 时勾销订阅；
如果 Observable 在 onResume 执行，那么当执行到 onPause 时勾销订阅；
如果 Observable 在 onPause 执行，那么当执行到 onStop 时勾销订阅；
如果 Observable 在 onStop 执行，那么当执行到 onDestroy 时勾销订阅；
如果 Observable 在 onDestroy 执行，则抛出异样；
故能够解释咱们在 onResume()生命周期中调用，onPause()勾销了订阅
三：组件化和 Base 库中应用 RxLifecycle
咱们通常须要在这封装来，不会这样独自间接在 Activity 中应用
我依据我之前的代码封装解说一下
第一步：咱们应用 RxJava 中被观察者 Observable, 去定义 compose()来绑定生命周期

// 这里咱们对被观察者，即网络接口，进行分封装，compose(lifecycle.bindUntilEvent(event))，咱们应用 bindUntilEvent 绑定生命周期办法，故须要传递 2 个参数，一个是 LifecycleProvider<ActivityEvent> 去调用 bindUntilEvent，一个是 ActivityEvent 参数
 public static <T> Observable<T> getObservable(
            Observable<T> apiObservable,
            LifecycleProvider<ActivityEvent> lifecycle,
            ActivityEvent event) {// showLog(request);
        Observable<T> observable;
        if (lifecycle != null) {
            // 手动治理移除监听生命周期.eg:ActivityEvent.STOP
            observable =
                    apiObservable
                            // 须要在这个地位增加
                            .compose(lifecycle.bindUntilEvent(event))
                            .onErrorResumeNext(new HttpResultFunction<>())
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread());
        } else {observable = getObservable(apiObservable);
        }
        return observable;
    }

第二步：咱们在 Model 层进行网络申请，咱们以获取验证码为例
在这里咱们被观察者订阅了观察者，Rxjava 实现了异步

 @Override
    public void getVerfitCode(LifecycleProvider<ActivityEvent> event, SendSMSBean sendSMSBean, LoginCallBack loginCallBack) {HttpObservable.getObservable(apiService.getSMS(sendSMSBean), event, ActivityEvent.DESTROY)// 次要是来剖析这个的，之前须要的 2 个参数，event 这个参数由他的调用者给，ActivityEvent.DESTROY 生命周期，咱们给了 Destroy()，这是一个枚举类型
        // 那么他的调用者 mvp 模式下，交由 P 层调用传入 LifecycleProvider<ActivityEvent> 这个参数
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new HttpObserver<String>() {// 订阅，HttpObserver 观察者
                    @Override
                    public void onSuccess(String response) {loginCallBack.getCodeSuccess(response);
                    }

                    @Override
                    public void onFail(boolean connect, int code, String msg) {loginCallBack.getCodeFail(connect, code, msg);

                    }

                    @Override
                    public void onStart(Disposable disposable) {}});
}

第三步：P 层实现类 LoginPresenter 中这个办法中传递给了 Mode 层实现类 LoginModel 中参数，那么 getProvider()办法获取到了 LifecycleProvider<ActivityEvent> 这个参数

public void getVerfitCode(String phone, String ip, int codeType) {SendSMSBean sendSMSBean = new SendSMSBean(phone, ip, codeType);
        mode.getVerfitCode(getProvider(), sendSMSBean, this);


    }

第四步：交由 getProvider()获取到参数，这是在我封装的 BaseProvider 中实现的

private LifecycleProvider<ActivityEvent> provider;
    private LifecycleProvider<FragmentEvent> fragmentProvider;
    public BasePresenter(LifecycleProvider<ActivityEvent> provider,ActivityEvent event){this.provider=provider;}
    public BasePresenter(LifecycleProvider<FragmentEvent> fragmentProvider,FragmentEvent event){this.fragmentProvider=fragmentProvider;}
    public LifecycleProvider<ActivityEvent> getProvider(){return provider;}
    public LifecycleProvider<FragmentEvent> getFragmentProvider(){return fragmentProvider;}

那么具体实现类 LoginPresenter，谁实现了 LoginPresenter 就传递过来


    public LoginPresenter(LifecycleProvider<ActivityEvent> provider, ActivityEvent event) {super(provider, event);// 调用父类
        mode = new LoginModel();}

第五步：在 Activity 中具体实现是 LoginActivity 中 LoginActivity 继承 BaseActivity，BaseActivity 继承 RxAppCompatActivity


    @Override
    protected LoginPresenter loadPresenter() {return new LoginPresenter(this, ActivityEvent.DESTROY);
    }
    // 这里传递 this 代表以后 Activity, 即 LoginActivity, 是继承了 RxAppCompatActivity 的
如果想晓得为什么 this, 能传入参数 LifecycleProvider<ActivityEvent>, 那么咱们就要看 RxAppCompatActivity 的源码了

RxAppCompatActivity 的源码

public abstract class RxAppCompatActivity extends AppCompatActivity implements LifecycleProvider<ActivityEvent> {private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

    public RxAppCompatActivity() {}

    @ContentView
    public RxAppCompatActivity(@LayoutRes int contentLayoutId) {super(contentLayoutId);
    }

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

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

    @NonNull
    @CheckResult
    public final <T> LifecycleTransformer<T> bindToLifecycle() {return RxLifecycleAndroid.bindActivity(this.lifecycleSubject);
    }。。。。。。局部源码
    // 能够看到他实现了接口 implements LifecycleProvider<ActivityEvent>
    // 故这个 this, 代表 LoginActivity 也实现了父类这个接口故绑定了 LoginActivity 的生命周期
   // Java 中子类会继承父类对于接口的实现。}

END: 愿以渺小启程以平凡完结

正文完
android
发表至： android
2021-07-01
 0
关于android:Android性能优化一线架构师带你看清APP启动优化内存优化崩溃优化屏幕适配隐藏的秘密
Flutter-Weekly-Issue-64
关于android:Android最受欢迎GitHub的控件
关于android:我为何弃用Jetpack的App-Startup