Android RxLife 一款輕量級別的RxJava生命週期管理庫

不怕天黑發表於2019-04-17
AndroidRxJava

簡介

RxLife是一款輕量級別的RxJava生命週期管理庫，程式碼侵入性極低，隨用隨取，不需要做任何準備工作，支援在Activity/Fragment 的任意生命週期方法斷開管道。

原理

RxLife通過Jetpack 下的 Lifecycle 獲取 Activity/Fragment 的生命週期變化，並通過Observable.lift(ObservableOperator) 操作符，注入自己實現的Observer物件(該物件能感知 Activity/Fragment的生命週期變化)，從而在onSubscribe(Disposable d)方法中拿到Disposable物件，隨後在相應的生命週期回撥裡執行Disposable.dispose()方法斷開管道，這樣就能將lift操作符上面的所有Disposable物件全部斷開。

為什麼要重複造輪子

熟悉RxJava的同學應該都知道trello/RxLifecycle 專案，它在目前的3.0.0版本中通過Lifecycle感知Activity/Fragment 的生命週期變化，並通過BehaviorSubject類及compose、takeUntil操作符來實現管道的中斷，這種實現原理有一點不足的是，它在管道斷開後，始終會往下游傳送一個onComplete事件，這對於在onComplete事件中有業務邏輯的同學來說，無疑是致命的。那為什麼會這樣呢？因為takeUntil操作符內部實現機制就是這樣的，有興趣的同學可以去閱讀takeUntil操作符的原始碼，這裡不展開。而RxLife就不會有這樣問題，因為在原理上RxLife就與trello/RxLifecycle不同，並且RxLife還在lift操作都的基礎上提供了一些額外的api，能有效的避免因RxJava內部類持有Activity/Fragment的引用，而造成的記憶體洩漏問題，下面開始講解。

gradle依賴

implementation 'com.rxjava.rxlife:rxlife:1.0.3'
複製程式碼

原始碼下載

用法

Observable.timer(10, TimeUnit.SECONDS)
        //預設在onDestroy時中斷管道
        .lift(RxLife.lift(this))
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
//或者
Observable.timer(10, TimeUnit.SECONDS)
        //指定在onStop時中斷管道
        .lift(RxLife.lift(this,Event.ON_STOP))
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

在Activity/Fragment 中，使用Observable的lift()操作符，方法中傳入RxLife.lift(this)，如果需要指定生命週期方法，額外再傳一個Event物件即可。怎麼樣？？是不是極其簡單，根本不需要做任何準備工作，程式碼侵入性極低。

處理記憶體洩漏

我們來看一個案例

public void leakcanary(View view) {
    Observable.timer(100, TimeUnit.MILLISECONDS)
            .map(new MyFunction<>()) //阻塞操作
            .lift(RxLife.lift(this))
            .subscribe(new Consumer<Long>() { //這裡使用匿名內部類，持有Activity的引用
                //注意這裡不能使用Lambda表示式，否則leakcanary檢測不到記憶體洩漏
                @Override
                public void accept(Long aLong) throws Exception {
                    Log.e("LJX", "accept =" + aLong);
                }
            });
}

//這裡使用靜態內部類，不會持有外部類的引用
static class MyFunction<T> implements Function<T, T> {

    @Override
    public T apply(T t) throws Exception {
        //當dispose時，第一次睡眠會被吵醒,接著便會進入第二次睡眠
        try {
            Thread.sleep(3000);
        } catch (Exception e) {

        }

        try {
            Thread.sleep(30000);
        } catch (Exception e) {

        }
        return t;
    }
}
複製程式碼

上面的程式碼會造成Activity無法回收，導致記憶體洩漏，我們用Leakcannry工具來檢測一下，發現確實造成來記憶體洩漏，如下

在這裡插入圖片描述
我們已經使用RxLife庫，會自動中斷管道，那為什麼還會造成記憶體洩漏呢？其實原因很簡單，我們只是中斷了管道，而沒有中斷上游對下游引用。看上面的截圖就能知道，上游始終持有下游的引用，而最下游的匿名內部類Consumer又持有了Activity的引用，所以就導致了Activity無法回收。

那為什麼中斷管道時，不會中斷上下游的引用呢？

首先有一點我們需要明確，呼叫Disposable.dispose()方法來斷開管道，並不是真正意義上的將上游與下游斷開，它只是改變了管道上各個Observer物件的一個標誌位的值，我們來看一下LambdaObserver類的原始碼就會知道

@Override
    public void dispose() {
        DisposableHelper.dispose(this);
    }
複製程式碼

呃呃，只有一行程式碼，我們繼續

public static boolean dispose(AtomicReference<Disposable> field) {
        Disposable current = field.get(); //此處得到上游的Disposable物件
        Disposable d = DISPOSED;
        if (current != d) {
            current = field.getAndSet(d); //更改自己的標誌位為DISPOSED
            if (current != d) {
                if (current != null) {
                    current.dispose();//關閉上游的Disposable物件
                }
                return true;
            }
        }
        return false;
    }
複製程式碼

可以看到，這裡只做了兩件事，一是更改自己的標誌位，二是呼叫上游的dispose()方法，其實你只要多看看，你就發現，RxJava內部大多數Observer在dispose()方法都會幹這兩件事。

到這，我們該如何解決這個記憶體洩漏問題呢？其實，RxJava早就想到了這一點，它給我們提供了一個onTerminateDetach()操作符，這個操作符會在onError(Throwable t)、onComplete()、dispose()這個3個時刻，斷開上游對下游的引用，我們來看看原始碼，原始碼在ObservableDetach類中

@Override
public void dispose() {
    Disposable d = this.upstream;
    this.upstream = EmptyComponent.INSTANCE;//上游重新賦值
    this.downstream = EmptyComponent.asObserver();//下游重新賦值
    d.dispose();//呼叫上游的dispose()方法
}

@Override
public void onError(Throwable t) {
    Observer<? super T> a = downstream;
    this.upstream = EmptyComponent.INSTANCE;//上游重新賦值
    this.downstream = EmptyComponent.asObserver();//下游重新賦值
    a.onError(t); //呼叫下游的onError方法
}

@Override
public void onComplete() {
    Observer<? super T> a = downstream;
    this.upstream = EmptyComponent.INSTANCE;//上游重新賦值
    this.downstream = EmptyComponent.asObserver();//下游重新賦值
    a.onComplete();//呼叫下游的onComplete方法
}

複製程式碼

到這，我們就知道該怎麼做了，下面這樣寫就安全了

Observable.timer(100, TimeUnit.MILLISECONDS)
        .map(new MyFunction<>())//阻塞操作
        .onTerminateDetach() //管道斷開時，中斷上游對下游的引用
        .lift(RxLife.lift(this)) //預設在onDestroy時斷開管道
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

可是，每次都要這樣寫嗎？有沒有更簡單的，有，RxLife提供了RxLife.compose(LifecycleOwner)方法，內部就是將onTerminateDetach、lift這兩個操作符整合在了一起，接下來，看看如何使用

Observable.timer(100, TimeUnit.MILLISECONDS)
        .map(new MyFunction<>())//阻塞操作
         //注意這裡使用compose操作符
        .compose(RxLife.compose(this))//預設在onDestroy時中斷管道，並中斷下下游之間的引用
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

如果需要指定生命週期的方法，也可以

Observable.timer(100, TimeUnit.MILLISECONDS)
        .map(new MyFunction<>())//阻塞操作
         //注意這裡使用compose操作符
        .compose(RxLife.compose(this, Event.ON_STOP))//指定在onStop時斷開管道
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
    }
複製程式碼

大多數情況下，我們希望觀察者能主執行緒進行回撥，也許你會這樣寫

Observable.timer(100, TimeUnit.MILLISECONDS)
        .map(new MyFunction<>())//阻塞操作
        .observeOn(AndroidSchedulers.mainThread()) //在主執行緒回撥
        .compose(RxLife.compose(this, Event.ON_STOP))//指定在onStop回撥時中斷管道，並中斷上下游引用
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

如果你是用RxLife的話，就可以這樣寫，使用RxLife.composeOnMain方法

Observable.timer(100, TimeUnit.MILLISECONDS)
        .map(new MyFunction<>())//阻塞操作
        //在主執行緒程式回撥，在onStop回撥時中斷管道，並中斷上下游引用
        .compose(RxLife.composeOnMain(this, Event.ON_STOP))
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

RxLife類就只有6個靜態方法，如下

shshs

注意，前方高能預警！！！！！！！

結合RxLife使用Observable的lift、compose操作符時，下游除了subscribe操作符外最好不要有其它的操作符，前面講過，當呼叫Disposable.dispose()時，它會往上一層一層的呼叫上游的dispose()方法，如果下游有Disposable物件，是呼叫不到的，如果此時下游有自己的事件需要傳送，那麼就無法攔截了。 如：

Observable.just(1)
        .compose(RxLife.compose(this))
        .flatMap((Function<Integer, ObservableSource<Long>>) integer -> {
            //每隔一秒傳送一個資料，共10個
            return Observable.intervalRange(0, 10, 0, 1, TimeUnit.SECONDS);
        })
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

這樣，即使Activity關閉了，觀察者每隔一秒後，依然能收到來自上游的事件，因為compose無法切斷下游的管道，我們改一下上面的程式碼

Observable.just(1)
        .flatMap((Function<Integer, ObservableSource<Long>>) integer -> {
            //每隔一秒傳送一個資料，共10個
            return Observable.intervalRange(0, 10, 0, 1, TimeUnit.SECONDS);
        })
        .compose(RxLife.compose(this))
        .subscribe(aLong -> {
            Log.e("LJX", "accept =" + aLong);
        });
複製程式碼

這樣ok了，其實這不是RxLife的問題，使用鼎鼎大名的trello/RxLifecycle庫也是一樣的，因為RxJava的設計就是如此，上游拿不到下游的Disposable物件，所以，我們在使用RxLife時，一定要注意在lift或者compose操作符的下游，除了subscribe操作符外最好不要有其它的操作符，這一點一定需要注意。

小彩蛋

RxLife類裡面的6個靜態方法，皆適用於Flowable、Observable、Single、Maybe、Completable這5個被觀察者物件，道理都一樣，這裡不在一一講解。

結尾

Ok，RxLife的使用基本就介紹完了，到這我們會發現，使用RxLife庫，我們只需要關注一個類即可，那即是RxLife類，api簡單功能卻強大。敢興趣的同學，可以去閱讀RxLife的原始碼，有疑問，請留言，我會在第一時間作答。

RxLife結合HttpSender傳送請求，簡直不要太爽。

HttpSender詳情請點選HttpSender OkHttp+RxJava超好用、功能超級強大的Http請求框架

相關文章