RxJava大家应该都用过或者听过，在用RxJava的时候当被观察者(Observable)和观察者(Observer)产生订阅关系后没有及时释放这种subscription就很容易产生内存泄漏，一个典型的场景就是使用RxJava发起网络请求，此时应用程序被杀掉，这种订阅关系就没有得到及时释放。当然这种情况在onDestroy中手动进行判断也行。如果是这种场景，发起的网络请求还没成功返回，此时应用进入后台，这时候就算请求成功返回也不应该更新UI，这种情况在使用RxJava的情况下怎么处理？
我们遇到的情况早有大神提供了解决方案，就是RxLifecycle开源库，官方的定义：
RxLifecycle
This library allows one to automatically complete sequences based on a second lifecycle stream.
This capability is useful in Android, where incomplete subscriptions can cause memory leaks.
简单来讲就是可以用来处理RxJava产生的内存泄漏。今天我们主要看下RxLifecycle的几种使用方式。后面有机会再分析下源码。
主要有下面几种使用方式：
1 bindToLifecycle
2 bindUntilEvent
3 LifecycleProvider
首先需要在模块的build.gradle中添加依赖：
compile 'com.trello.rxlifecycle2:rxlifecycle-components:2.1.0'
compile 'com.trello.rxlifecycle2:rxlifecycle-navi:2.1.0'
1.bindToLifecycle
这种方式可以自动根据Activity或者Fragment的生命周期进行解绑，用起来也很方便,Avtivity需要继承RxActivity， Fragment则需要继承RxFragment
public class MainActivity extends BaseActivity{
@Override
protected void onStart() {
super.onStart();
Observable.interval(1, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.compose(this.<Long>bindToLifecycle())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long num) throws Exception {
Timber.tag(TAG).d("onStart, running num : " + num);
}
});
}
}
这里在onStart中进行绑定，如果Activity进入onStop生命周期的时候就会停止Observable，看一下日志：
bindToLifecycle就是会自动绑定生命周期，我们看下Activity生命周期,很明显在onCreate中bindToLifecycle就会在onDestroy中进行解绑，其他的一一对应就是。
/**
* Lifecycle events that can be emitted by Activities.
*/
public enum ActivityEvent {
CREATE,
START,
RESUME,
PAUSE,
STOP,
DESTROY
}
Fragment也有对应的生命周期，也是对称对应的。
/**
* Lifecycle events that can be emitted by Fragments.
*/
public enum FragmentEvent {
ATTACH,
CREATE,
CREATE_VIEW,
START,
RESUME,
PAUSE,
STOP,
DESTROY_VIEW,
DESTROY,
DETACH
}
2.bindUntilEvent
见名知意，就是可以和制定的生命周期进行绑定，这种方式比上面的灵活，比如可以在一个按钮中绑定onStart的事件，而不必要一定要卸载onStart中。
我在上面的Activity中添加一个按钮，点击事件在getData(View view)中，看下代码：
public void getData(View view) {
Observable observable = Observable.interval(1, TimeUnit.SECONDS).
subscribeOn(Schedulers.io()).compose(this.bindUntilEvent(ActivityEvent.PAUSE));
observable.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long num) throws Exception {
Timber.tag(TAG).d("getData, running until num : " + num);
}
});
}
按我们的预期，就是在Activity进入onPause时，Observable会停止发送数据，看下打印的日志是不是这样的：
基本上面这两种方式就够用了，下面的方式LifecycleProvider在MVP的模式中用处就比较大了。我们接着往下看。
3.LifecycleProvider
使用方式就是，首先继承NaviActivity，然后在Activity中加上这句话
LifecycleProvider<ActivityEvent> provider = NaviLifecycle.createActivityLifecycleProvider(this);
这样就可以通过provider监听生命周期了。我这里在初始化presenter的时候传递过去
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
......
//初始化Presenter
presenter = new Presenter(provider);
}
在Activity中添加一个按钮，通过延时3秒模拟网络请求，请求成功后更新UI。这里通过 provider发送生命周期事件，然后在onNext中判断事件类型，如果已经Activity已经进入onPause onStop onDestroy中的其中一个，就不再更新UI了，并且通过Disposable断开连接。
FactoryModel.getModel(Token.STRING_MODEL).params(params).execute(new CallBack<String>() {
@Override
public void onSuccess(final String data) {
provider.lifecycle().subscribe(new Observer<ActivityEvent>() {
@Override
public void onSubscribe(Disposable d) {
disposable = d;
}
@Override
public void onNext(ActivityEvent activityEvent) {
Timber.tag("Presenter_TAG").i("received activityEvent, activityEvent = %s" , activityEvent.name());
if (null != disposable && disposable.isDisposed()){
Timber.tag("Presenter_TAG").i("disposable isDisposed");
return;
}
if (activityEvent == ActivityEvent.PAUSE || activityEvent == ActivityEvent.STOP || activityEvent == ActivityEvent.DESTROY){
Timber.tag("Presenter_TAG").e("do not refresh UI, activityEvent = %s", activityEvent.name());
onComplete();
return;
}
if (isViewAttached()) {
Timber.tag("Presenter_TAG").i("refresh UI, activityEvent = %s" , activityEvent.name());
view.showData(data);
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
if (null != disposable && !disposable.isDisposed()){
disposable.dispose();
Timber.tag("Presenter_TAG").d("LifecycleProvider disposed");
}
}
});
}
});
看一下正常请求成功的日志,和预期一样，正常更新UI了。
下面我们来搞一下破坏，在刚发起网络请求后，按home按键将APP切到后台，这样Activity就进入onStop的生命周期，那么即使网络请求成功也应该再更新UI了，看下日志是不是这样的：
最终UI也是没有更新的。我们在下面的逻辑中切断了订阅关系，那么下次再次点击按钮发起网络请求是还能正常使用
provider吗？
if (activityEvent == ActivityEvent.PAUSE || activityEvent == ActivityEvent.STOP || activityEvent == ActivityEvent.DESTROY){
Timber.tag("Presenter_TAG").e("do not refresh UI, activityEvent = %s", activityEvent.name());
onComplete();
return;
}
其实是可以的，看一下Demo的日志：
那么是怎么回事？其实就在下面这个代码中：
provider.lifecycle()
在获取Observable时会清楚原先的特征，我们看下源码：
private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();
@Override
@NonNull
@CheckResult
public Observable<ActivityEvent> lifecycle() {
return lifecycleSubject.hide();
}
再跟进去BehaviorSubject,其中以后一句注释Hides the identity of this Observable and its Disposable，最后会返回一个新的Observable :
/**
* Hides the identity of this Observable and its Disposable.
* <p>Allows hiding extra features such as {@link io.reactivex.subjects.Subject}'s
* {@link Observer} methods or preventing certain identity-based
* optimizations (fusion).
* <dl>
* <dt><b>Scheduler:</b></dt>
* <dd>{@code hide} does not operate by default on a particular {@link Scheduler}.</dd>
* </dl>
* @return the new Observable instance
*
* @since 2.0
*/
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Observable<T> hide() {
return RxJavaPlugins.onAssembly(new ObservableHide<T>(this));
}
4.总结
RxLifecycle的侵入性还是比较低的，基本不需要改动原来的代码就可以实现生命周期的监听，也提供了防止RxJava订阅关系内存泄漏的另外一种解决方案，还是很不错的。
今天的分享就到这了，后面有机会和大家分享下RxLifecycle的源码。
平时工作也比较忙，写博客真的是需要耐力，如果对大家有帮助欢迎关注和点赞哈。
最后感谢@右倾倾的理解和支持哈。
以上！
