Android 第三方庫RxLifecycle使用

1.簡單介紹RxLifecycle

1.1.使用原因。

　　在使用rxjava的時候，如果沒有及時解除訂閱，在退出activity的時候，異步線程還在執行。

　　對activity還存在引用，此時就會產生內存泄漏。

　　RxLifecycle就是為了解決rxjava導致的內存泄漏而產生的。

 

 

1.2.RxLifecycle可以做到什么呢？　　

　　它可以讓Observable發布的事件和當前的組件綁定，實現生命周期同步。

　　從而實現當前組件生命周期結束時，自動取消對Observable訂閱。

　　核心思想：通過監聽Activity、Fragment的生命周期，來自動斷開訂閱防止內存泄漏。

 

1.3.參考文獻。

　　RxAndroid的github地址：https://github.com/ReactiveX/RxAndroid

　　Rxlifecycle的github地址：https://github.com/trello/RxLifecycle

　　參考文章：Rxlifecycle使用詳解。

　　參考文章：在mvp中使用rxlifecycle避免rxjava的內存泄漏。　　

 

2.使用方法

2.1.添加最新的依賴　

//rxjava的依賴
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.1.7'
//rxlifecycle的依賴
compile 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle-kotlin:2.2.1'

 

 

2.2.Activity以及Fragment的繼承

　　Activity需要繼承RxAppCompatActivity。==>比如這么一個類

public class BaseActivity extends RxAppCompatActivity

　　Fragment需要繼承RxFragment。==>比如這么一個類

public abstract class BaseFragment<T extends IBasePresenter>
        extends RxFragment
        implements IBaseView<T>

 

 

2.3.綁定生命周期。

　　自己寫一個接口，里面定義一個bindToLife()函數。　　

 /**
     * 綁定生命周期
     */
    <T> LifecycleTransformer<T> bindToLife();

　　這個bindToLife()是自定義的名字，這里就叫做bindToLife好了。

　　這個接口是自己定義的一個接口，我讓Fragment來繼承這個接口。

　　這個返回的是一個LifecycleTransformer<T>，這個官方的一個類。而且這里使用了泛型，更加通用了。

 

 

2.4.在自己的Fragment中實現這個接口函數。　

/**
     * 綁定生命周期
     */
    @Override
    public <T> LifecycleTransformer<T> bindToLife() {
        return bindUntilEvent(FragmentEvent.DESTROY);
    }

　　這里調用了官方的一個bindUntilEvent的方法，以此函數來綁定生命周期。

　　這里的FragmentEvent.DESTROY，顧名思義，就是當Fragment銷毀的時候，自動解除訂閱關系。

　　

　　注意：這里使用了FragmentEvent類，其中的CREATE/START/RESUME/PAUSE/STOP/DESTROY　　

　　　　    分布對應生命周期內的方法。使用bindUntilEvent指定在哪個生命周期方法調用示取消訂閱。

 

 

2.5.在請求API函數的時候，執行自己寫的bindToLife()

　   調用Observable<T>.compose(執行接口中的bindToLife())

　　compose里面的東西應該是：LifecycleTransformer<T>。　

 

3.對於Rxlifecycle的理解

3.1.使用原因就不用多說了，解決RxJava導致的內存泄漏。

 

 

3.2.因為activity和fragment控制切換線程的時候，引用沒有清除干凈，所以就把手腳着重於activity和fragment的

　　生命周期了，就是說，如果你的活動如果碰到意外或者用戶主動銷毀，那么也斷開訂閱，就是訂閱的生命周期

　　和活動的生命周期已經融為一體了，那就不用擔心再發生內存泄漏了，所以這種綁定生命周期的方法是從根本

　　上解決了內存泄漏。感覺沒有更好的方法解決了。

 

 

3.3.其實官方為了兩種解決方案。

　　一種是手動取消訂閱，我不知道怎么用，也沒有實戰過。

　　這里提供一下大神的文章：RxAndroid之Rxlifecycle使用。

　　手動設置在activity onPause的時候取消訂閱。

private static final String TAG = "RxLifecycle";

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Log.d(TAG, "onCreate()");
    setContentView(R.layout.activity_main);

    Observable.interval(1, TimeUnit.SECONDS)
            .doOnUnsubscribe(new Action0() {
                @Override
                public void call() {
                    Log.i(TAG, "Unsubscribing subscription from onCreate()");
                }
            })
            //Note:手動設置在activity onPause的時候取消訂閱
            .compose(this.<Long>bindUntilEvent(ActivityEvent.PAUSE))
            .subscribe(new Action1<Long>() {
                @Override
                public void call(Long num) {
                    Log.i(TAG, "Started in onCreate(), running until onPause(): " + num);
                }
            });
}

 

　　手動設置在activity的onDestroy的時候取消訂閱。

@Override
protected void onResume() {
    super.onResume();
    Log.d(TAG, "onResume()");

    // `this.<Long>` is necessary if you're compiling on JDK7 or below.
    // If you're using JDK8+, then you can safely remove it.
    Observable.interval(1, TimeUnit.SECONDS)
            .doOnUnsubscribe(new Action0() {
                @Override
                public void call() {
                    Log.i(TAG, "Unsubscribing subscription from onResume()");
                }
            })
            //Note:手動設置在activity onDestroy的時候取消訂閱
            .compose(this.<Long>bindUntilEvent(ActivityEvent.DESTROY))
            .subscribe(new Action1<Long>() {
                @Override
                public void call(Long num) {
                    Log.i(TAG, "Started in onResume(), running until in onDestroy(): " + num);
                }
            });
}

 

　　自動設置取消訂閱，默認在onStart的時候調用，在onStop的時候取消訂閱。

@Override
protected void onStart() {
    super.onStart();
    Log.d(TAG, "onStart()");// Using automatic unsubscription, this should determine that the correct time to
    // unsubscribe is onStop (the opposite of onStart).
    Observable.interval(1, TimeUnit.SECONDS)
            .doOnUnsubscribe(new Action0() {
                @Override
                public void call() {
                    Log.i(TAG, "Unsubscribing subscription from onStart()");
                }
            })
            //Note:bindToLifecycle的自動取消訂閱示例，因為是在onStart的時候調用，所以在onStop的時候自動取消訂閱
            .compose(this.<Long>bindToLifecycle())
            .subscribe(new Action1<Long>() {
                @Override
                public void call(Long num) {
                    Log.i(TAG, "Started in onStart(), running until in onStop(): " + num);
                }
            });
}