Android官方架構組件Lifecycle:生命週期組件詳解&原理分析

概述

在過去的谷歌IO大會上，Google官方向咱們推出了 Android Architecture Components,其中談到Android組件處理生命週期的問題，向咱們介紹了 Handling Lifecycles。

同時，如何利用 android.arch.lifecycle 包提供的類來控制數據、監聽器等的 lifecycle。同時，LiveData 與 ViewModel 的 lifecycle 也依賴於 Lifecycle 框架。

1、Lifecycle簡介&基礎使用

爲何要引進Lifecycle？

咱們在處理Activity或者Fragment組件的生命週期相關時，不可避免會遇到這樣的問題：

咱們在Activity的onCreate()中初始化某些成員（好比MVP架構中的Presenter，或者AudioManager、MediaPlayer等），而後在onStop中對這些成員進行對應處理，在onDestroy中釋放這些資源，這樣致使咱們的代碼也許會像這樣：

class MyPresenter{
    public MyPresenter() {
    }

    void create() {
        //do something
    }

    void destroy() {
        //do something
    }
}

class MyActivity extends AppCompatActivity {
    private MyPresenter presenter;

    public void onCreate(...) {
        presenter= new MyPresenter ();
        presenter.create();
    }

    public void onDestroy() {
        super.onDestroy();
        presenter.destory();
    }
}
複製代碼

代碼沒有問題，關鍵問題是，實際生產環境中 ，這樣的代碼會很是複雜，你最終會有太多的相似調用而且會致使 onCreate() 和 onDestroy() 方法變的很是臃腫。

解決方案

Lifecycle 是一個類，它持有關於組件（如 Activity 或 Fragment）生命週期狀態的信息，而且容許其餘對象觀察此狀態。

咱們只須要2步：

一、Prestener繼承LifecycleObserver接口

public interface IPresenter extends LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(@NotNull LifecycleOwner owner);

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(@NotNull LifecycleOwner owner);

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event);
}

public class BasePresenter implements IPresenter {
        
    private static final String TAG = "com.qingmei2.module.base.BasePresenter";    

    @Override
    public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) {

    }

    @Override
    public void onCreate(@NotNull LifecycleOwner owner) {
        Log.d("tag", "BasePresenter.onCreate" + this.getClass().toString());
    }

    @Override
    public void onDestroy(@NotNull LifecycleOwner owner) {
        Log.d("tag", "BasePresenter.onDestroy" + this.getClass().toString());
    }
}
複製代碼

這裏我直接將我想要觀察到Presenter的生命週期事件都列了出來，而後封裝到BasePresenter 中，這樣每個BasePresenter 的子類都能感知到Activity容器對應的生命週期事件，並在子類重寫的方法中，對應相應行爲。

二、在Activity/Fragment容器中添加Observer：

public class MainActivity extends AppCompatActivity {
    private IPresenter mPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("tag", "onCreate" + this.getClass().toString());
        setContentView(R.layout.activity_main);
        mPresenter = new MainPresenter(this);
        getLifecycle().addObserver(mPresenter);//添加LifecycleObserver
    }

    @Override
    protected void onDestroy() {
        Log.d("tag", "onDestroy" + this.getClass().toString());
        super.onDestroy();
    }
}
複製代碼

如此，每當Activity發生了對應的生命週期改變，Presenter就會執行對應事件註解的方法：

除onCreate和onDestroy事件以外，Lifecycle一共提供了全部的生命週期事件，只要 經過註解進行聲明，就可以使LifecycleObserver觀察到對應的生命週期事件：

//如下爲logcat日誌
01-08 23:21:01.702  D/tag: onCreate  class com.qingmei2.mvparchitecture.mvp.ui.MainActivity
01-08 23:21:01.778  D/tag: onCreate  class com.qingmei2.mvparchitecture.mvp.presenter.MainPresenter

01-08 23:21:21.074  D/tag: onDestroy  class com.qingmei2.mvparchitecture.mvp.presenter.MainPresenter
01-08 23:21:21.074  D/tag: onDestroy  class com.qingmei2.mvparchitecture.mvp.ui.MainActivity
複製代碼

public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }
複製代碼

2、原理分析

先說結論：

借鑑Android 架構組件（一）——Lifecycle, @ShymanZhu的一張圖進行簡單的歸納：

咱們先將重要的這些類挑選出來：

• LifecycleObserver接口（ Lifecycle觀察者）：實現該接口的類，經過註解的方式，能夠經過被LifecycleOwner類的addObserver(LifecycleObserver o)方法註冊,被註冊後，LifecycleObserver即可以觀察到LifecycleOwner的生命週期事件。

• LifecycleOwner接口（Lifecycle持有者）：實現該接口的類持有生命週期(Lifecycle對象)，該接口的生命週期(Lifecycle對象)的改變會被其註冊的觀察者LifecycleObserver觀察到並觸發其對應的事件。

• Lifecycle(生命週期)：和LifecycleOwner不一樣的是，LifecycleOwner自己持有Lifecycle對象，LifecycleOwner經過其Lifecycle getLifecycle()的接口獲取內部Lifecycle對象。

• State(當前生命週期所處狀態)：如圖所示。

• Event(當前生命週期改變對應的事件)：如圖所示，當Lifecycle發生改變，如進入onCreate,會自動發出ON_CREATE事件。

瞭解了這些類和接口的職責，接下來原理分析就簡單不少了，咱們以Fragment爲例，來看下實際Fragment等類和上述類或接口的聯繫：

一、Fragment：LifecycleOwner

• Fragment(Activity同理，咱們 本文以Fragment爲例，下同)：實現了LifecycleOwner接口，這意味着Fragment對象持有生命週期對象（Lifecycle），並能夠經過Lifecycle getLifecycle()方法獲取內部的Lifecycle對象：

public class Fragment implements xxx, LifecycleOwner {
    
    //...省略其餘

   LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}
複製代碼

能夠看到，實現的getLifecycle()方法，實際上返回的是 LifecycleRegistry 對象，LifecycleRegistry對象實際上繼承了 Lifecycle，這個下文再講。

持有Lifecycle有什麼做用呢？實際上在Fragment對應的生命週期內，都會發送對應的生命週期事件給內部的 LifecycleRegistry對象處理：

public class Fragment implements xxx, LifecycleOwner {
    //...
    void performCreate(Bundle savedInstanceState) {
        onCreate(savedInstanceState);  //1.先執行生命週期方法
        //...省略代碼
        //2.生命週期事件分發
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

    void performStart() {
        onStart();
        //...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    void performResume() {
         onResume();
        //...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

    void performPause() {
        //3.注意，調用順序變了
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        //...
        onPause();
    }

    void performStop() {
       mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        //...
        onStop();
    }

    void performDestroy() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        //...
        onDestroy();
    }
}
複製代碼

隨着Fragment不一樣走到不一樣的生命週期，除了暴露給咱們的生命週期方法onCreate/onStart/..../onDestroy等，同時，Fragment內部的Lifecycle對象（就是mLifecycleRegistry）還將生命週期對應的事件做爲參數傳給了 handleLifecycleEvent() 方法。

同時，你會發現Fragment中performCreate()、performStart()、performResume()會先調用自身的onXXX()方法，而後再調用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中會先LifecycleRegistry的handleLifecycleEvent()方法 ，而後調用自身的onXXX()方法。

參照Android 架構組件（一）——Lifecycle, @ShymanZhu文中的時序圖：

咱們從圖中能夠看到，當Fragment將生命週期對應的事件交給其內部的Lifecycle處理後， LifecycleObserver （就是咱們上文自定義的Presenter），就可以接收到對應的生命週期事件，這是如何實現的呢？

二、LifecycleRegistry：Lifecycle

首先確認一點，LifecycleRegistry 就是 Lifecycle 的子類：

public class LifecycleRegistry extends Lifecycle {
}
複製代碼

咱們看一下 Lifecycle 類

public abstract class Lifecycle {

        //註冊LifecycleObserver （好比Presenter）
        public abstract void addObserver(@NonNull LifecycleObserver observer);
        //移除LifecycleObserver 
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
        //獲取當前狀態
        public abstract State getCurrentState();

        public enum Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY
        }
        
       public enum State {
            DESTROYED,
            INITIALIZED,
            CREATED,
            STARTED,
            RESUMED;

            public boolean isAtLeast(@NonNull State state) {
                return compareTo(state) >= 0;
            }
       }
}
複製代碼

Lifecycle沒什麼要講的，幾個抽象方法也能看懂，做爲Lifecycle的子類，LifecycleRegistry 一樣也能經過addObserver方法註冊LifecycleObserver （就是Presenter），當LifecycleRegistry 自己的生命週期改變後（能夠想象，內部必定有一個成員變量State記錄當前的生命週期），LifecycleRegistry 就會逐個通知每個註冊的LifecycleObserver ，並執行對應生命週期的方法。

咱們看一下LifecycleRegistry 的handleLifecycleEvent()方法：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }
複製代碼

看方法的名字咱們就能夠知道，handleLifecycleEvent方法會經過 getStateAfter 獲取當前應處的狀態並修改 Lifecycle自己的State 值，緊接着遍歷所 LifecycleObserver 並同步且通知其狀態發生變化，所以就能觸發LifecycleObserver 對應的生命週期事件。

實際上LifecycleRegistry 自己仍是有不少值得一提之處，本文只闡述清楚原理，暫不涉及源碼詳解。

一些小Tips

一、嘗試複用LifecycleRegistry

首先，LifecycleRegistry 自己就是一個成熟的 Lifecycle 實現類，它被實例化在Activity和Fragment中使用，若是咱們須要自定義LifecycleOwner 並實現接口須要返回一個Lifecycle實例，徹底能夠直接在自定義LifecycleOwner中new一個LifecycleRegistry成員並返回它（簡而言之就是：直接拿來用便可）。

如下是Google官方文檔：

LifecycleRegistry: An implementation of Lifecycle that can handle multiple observers. It is used by Fragments and Support Library Activities. You can also directly use it if you have a custom LifecycleOwner.

二、註解和DefaultLifecycleObserver的取捨

其次，Google的Lifecycle庫中提供了一個 DefaultLifecycleObserver 類,方便咱們直接實現LifecycleObserver接口，相比較於文中demo所使用的註解方式，Google官方更推薦咱們使用 DefaultLifecycleObserver 類，並聲明

一旦Java 8成爲Android的主流，註釋將被棄用，因此介於DefaultLifecycleObserver和註解二者之間,更推薦使用 DefaultLifecycleObserver 。

官方原文：

/*
 * If you use <b>Java 8 Language</b>, then observe events with {@link DefaultLifecycleObserver}.
 * To include it you should add {@code "android.arch.lifecycle:common-java8:<version>"} to your
 * build.gradle file.
 * <pre>
 * class TestObserver implements DefaultLifecycleObserver {
 *     {@literal @}Override
 *     public void onCreate(LifecycleOwner owner) {
 *         // your code
 *     }
 * }
 * </pre>
 * If you use <b>Java 7 Language</b>, Lifecycle events are observed using annotations.
 * Once Java 8 Language becomes mainstream on Android, annotations will be deprecated, so between
 * {@link DefaultLifecycleObserver} and annotations,
 * you must always prefer {@code DefaultLifecycleObserver}.
 */
複製代碼

* 三、Lifecycles 的最佳實踐

本小節內容節選自《[譯] Architecture Components 之 Handling Lifecycles》 做者：zly394 連接：juejin.im/post/5937e1…

• 保持 UI 控制器（Activity 和 Fragment）儘量的精簡。它們不該該試圖去獲取它們所需的數據；相反，要用 ViewModel來獲取，而且觀察 LiveData將數據變化反映到視圖中。

• 嘗試編寫數據驅動（data-driven）的 UI，即 UI 控制器的責任是在數據改變時更新視圖或者將用戶的操做通知給 ViewModel。

• 將數據邏輯放到 ViewModel 類中。ViewModel 應該做爲 UI 控制器和應用程序其它部分的鏈接服務。注意：不是由 ViewModel 負責獲取數據（例如：從網絡獲取）。相反，ViewModel 調用相應的組件獲取數據，而後將數據獲取結果提供給 UI 控制器。

• 使用Data Binding來保持視圖和 UI 控制器之間的接口乾淨。這樣可讓視圖更具聲明性，而且儘量減小在 Activity 和 Fragment 中編寫更新代碼。若是你喜歡在 Java 中執行該操做，請使用像Butter Knife 這樣的庫來避免使用樣板代碼並進行更好的抽象化。

• 若是 UI 很複雜，能夠考慮建立一個 Presenter 類來處理 UI 的修改。雖然一般這樣作不是必要的，但可能會讓 UI 更容易測試。

• 不要在 ViewModel 中引用View或者 Activity的 context。由於若是ViewModel存活的比 Activity 時間長（在配置更改的狀況下），Activity 將會被泄漏而且沒法被正確的回收。

總結

總而言之，Lifecycle仍是有可取之處的，相對於其它架構組件之間的配合，Lifecycle更簡單且獨立（實際上配合其餘組件味道更佳）。

本文旨在分析Lifecycle框架相關類的原理，將不會對Lifecycle每一行的源碼進行深刻地探究，若是有機會，筆者將嘗試寫一篇源碼詳細解析。

參考&感謝

Lifecycle-aware Components 源碼分析 @chaosleong

Android 架構組件（一）——Lifecycle @ShymanZhu

--------------------------廣告分割線------------------------------

系列文章

爭取打造 Android Jetpack 講解的最好的博客系列：

• Android官方架構組件Lifecycle：生命週期組件詳解&原理分析
• Android官方架構組件ViewModel:從前世此生到追本溯源
• Android官方架構組件LiveData: 觀察者模式領域二三事
• Android官方架構組件Paging：分頁庫的設計美學
• Android官方架構組件Paging-Ex：爲分頁列表添加Header和Footer
• Android官方架構組件Paging-Ex：列表狀態的響應式管理
• Android官方架構組件Navigation：大巧不工的Fragment管理框架
• Android官方架構組件DataBinding-Ex:雙向綁定篇

Android Jetpack 實戰篇：

• 開源項目：MVVM+Jetpack實現的Github客戶端
• 開源項目：基於MVVM, MVI+Jetpack實現的Github客戶端
• 總結：使用MVVM嘗試開發Github客戶端及對編程的一些思考

---

關於我

Hello，我是卻把清梅嗅，若是您以爲文章對您有價值，歡迎 ❤️，也歡迎關注個人我的博客或者Github。

若是您以爲文章還差了那麼點東西，也請經過關注督促我寫出更好的文章——萬一哪天我進步了呢？

• 個人Android學習體系
• 關於文章糾錯
• 關於知識付費