Jetpack系列 - Lifecycle從入門到源碼

時間  2019-11-08
標籤 jetpack 系列 lifecycle 入門 源碼 简体版
原文   原文鏈接

這篇文章旨在用最簡單的方式教會你Lifecycle如何使用，及它的工做原理。java

Lifecycle介紹

Lifecycle是Google推出的JetPack框架組件的一個，主要是用來感知Activity和Fragment的生命週期，能夠幫你寫出更簡潔，通用的代碼。git

Lifecycle使用

總共兩步github

  1. 第一步，編寫本身的Observer類文件，並實現對應的監聽方法，經過註解實現對響應生命週期方法的監聽，代碼以下：
public class MyLifeObserver implements LifecycleObserver {

  private static final String TAG = "MyLifeObserver";

  // OnLifecycleEvent()內的註解Lifecycle.Event.XXX 對應不一樣的生命週期方法，你能夠根據須要監聽不一樣的生命週期方法。
  // 方法名能夠隨意，這裏爲了方便理解定義爲onResumeListener()。
  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  public void onResumeListener() {
    Log.d(TAG, "onResume: ");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  public void onPauseListener() {
    Log.d(TAG, "onPause: ");
  }

  @OnLifecycleEvent(Event.ON_DESTROY)
  public void onDestoryListener() {
    Log.d(TAG, "onDestory: ");
  }
複製代碼
  1. 第二步在被監聽的Activity/Fragment內註冊：
public class MainActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    getLifecycle().addObserver(new MyLifeObserver());
  }
}
複製代碼

無論你信不信，代碼已經寫完了！
bash


咱們跑一下代碼： 

2019-02-28 12:00:40.068 com.example.lifecycledemo D/MyLifeObserver: onResume: 
2019-02-28 12:00:46.091 com.example.lifecycledemo D/MyLifeObserver: onPause: 
2019-02-28 12:00:46.416 com.example.lifecycledemo D/MyLifeObserver: onDestory: 
複製代碼

Log 顯示咱們寫的 Observer 內的方法的確在 Activity 的指定週期內執行了。恭喜你，已經可以使用 Lifecycle 了！
可是注意幾點：網絡

  1. 一般咱們會 把MyLifeObserver 做爲內部類寫在另外一個 Activity/Fragment 中，以方便在監控到生命週期方法後作一些業務操做，以上代碼爲了快速看到效果而作了省略。
  2. 注意上面 Activity 的代碼中，咱們的 Activity 繼承了AppCompatActivity，AppCompatActivity 和 Fragment 都實現了LifecycleOwner 接口（Support Library 26.1.0以後的版本），因此能夠直接拿來使用。若是你被監控的 Actiivty 是自定義的 Activity，須要手動繼 承LifecycleOwner，具體操做以下：
1. 實現LifecycleOwner接口，並重寫getLifecycle方法。
2. 手動在每一個生命週期方法中作標記。
複製代碼

具體代碼以下：框架

public class MyActivity extends Activity implements LifecycleOwner {
  private LifecycleRegistry mLifecycleRegistry;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_my);
    //建立Lifecycle對象
    mLifecycleRegistry = *new*LifecycleRegistry(this);
    //作標記
    mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    //添加觀察者
    getLifecycle().addObserver(new MyLifeObserver());
  }

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

  @Override
  public void onStart() {
    super.onStart();
    //作標記
    mLifecycleRegistry.markState(Lifecycle.State.STARTED);
  }

  @Override
  protected void onResume() {
    super.onResume();
    //作標記
    mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    //作標記
    mLifecycleRegistry.markState(Lifecycle.State.DESTROYED); 
  }
}
複製代碼

至此，Lifecycle 的使用方法已經介紹完了，由於 AppCompatActivity 已經幫咱們實現了 LifecycleOwner 接口，因此同窗們注意活學活用。
好比：在封裝網絡請求工具時候，傳入當前 Activity 對象，當 Activity 對象生命週期爲 Destory 時，撤銷請求網絡的操做。 Lifecycle 用武之地還有不少，這裏只介紹最基礎的，你如今能夠思考如何經過 Lifecycle 來優化你的項目了。
若是你對Lifecyle的工做原理有興趣，請繼續閱讀，我會帶着你從源碼一步一步徹底理解 Lifecycle 的工做原理。 若是沒有興趣，能夠直接拉到文章末尾看總結~ide

Lifecycle的工做原理

咱們就以使用到的幾個類爲切入口，分析 Lifecycle 的工做原理。 咱們主要點進這幾個類看(Crtl+單擊類名)：LifecycleOwner.java，Lifecycle.java，LifecycleRegistry.java。工具

LifecycleOwner.java

這個很簡單，LifecycleOwner定義了一個getLifecycle()方法，經過@NonNull強制咱們返回Lifecycle對象。代碼以下：優化

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

複製代碼

Lifecycle.java

代碼以下：ui

public abstract class Lifecycle {
 
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {
    ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,
    ON_DESTROY,ON_ANY
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {

        DESTROYED,INITIALIZED,CREATED,STARTED, RESUMED;

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

Lifecycle的代碼也並很少，注意它是一個抽象類。Lifecycle內部經過兩個枚舉分別定義了組件的生命週期的狀態和事件。 下面這張圖摘自Android開發者官網,介紹了State和Event的關係：

摘自Android開發者官網

簡單說下這個圖怎麼看：看箭頭，好比 ON_CREATE 箭頭表示：State 從 INITIALIZED 變爲 CREATED，會觸發 ON_CREATE 的 Event。依次類推。

LifecycleRegistry.java

這個類的代碼比較多，是 Lifecycle 的子類，也是監聽組件聲明週期的核心類。咱們就從使用到的方法一個一個來看：

A.構造方法，主要初始化了 mLifecycleOwner 和當前組件的狀態(mState),沒什麼說的。

publicLifecycleRegistry(@NonNull LifecycleOwner provider) {
  mLifecycleOwner = new WeakReference<>(provider);
  mState = INITIALIZED;
}
複製代碼

B. 咱們在 Lifecycle 的使用部分，繼承了 LifecycleOwner，並在組件的生命週期內調用了 markState()方法。點進去以下：

public void markState(@NonNull State state) {
  moveToState(state);
}
複製代碼

C. 省去了一些複雜邏輯的代碼，咱們找到了這個核心的方法 sync():

private void moveToState(State next) {
 ...
  mHandlingEvent = true;
  sync();
  mHandlingEvent = false;
}

複製代碼

D. 一樣在 sync()方法中，忽略掉邏輯代碼，咱們發現了正真執行的兩個方法：backwardPass(),forwardPass()

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    while(!isSynced()) {
        mNewEventOccurred = false;
        if(mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState > newest = mObserverMap.newest();
        if(!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

複製代碼

E. 在 backwardPass()和 forwardPass()，調用了 observer.dispatchEvent(),看名字想必就是發送事件的方法了：

private void forwardPass(LifecycleOwner lifecycleOwner) {
    ...
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
    ...
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
 ...
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
 ...
}
複製代碼

F. 咱們點擊 dispatchEvent()方法，進入了下面這個靜態內部類中，這個類中，就能夠肯定了：Observer(下面代碼中的 mLifecycleObserver)觸監聽定生命週期的方法在這裏被觸發了。 可是咱們如何肯定這個方法的 mLifecycleObserver 就是咱們實現的 Observer 呢？這個靜態類還有一個方法，咱們點擊一下看它在哪裏被調用了：

static class ObserverWithState {
    State mState;
    GenericLifecycleObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.getCallback(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}
複製代碼

G. 很高興，咱們來到了 addObserver()方法，你必定還記得咱們在講解 Lifecycle 使用部分是，綁定 Observer 就是使用這個方法。

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState*statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState*previous = mObserverMap.putIfAbsent(observer, statefulObserver);
...
}
複製代碼

H. 最後咱們看一眼 LifecycleObserver接口(觀察者)，發現它是空的。其實咱們看到註解應該猜到，系統是經過 apt-processor(註釋處理器)將咱們的 Observer 轉換成 Lifecycle 真正須要類型 的Observer，下面是 OnLifecycleEvent 註解的聲明：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}
複製代碼

總結

看到這裏，相信你們對 Lifecycle 的工做原理已經理解的差很少了吧，跟接口回調相似，咱們建立了 Obersver 的對象，而後將 Obersver 的引用交給 Lifecycle，在組件生命週期方法執行時，調用 Observer 的相應的方法。

固然，咱們本身也能夠寫一套接口回調來監控組件的生命週期，可是咱們不得不考慮在哪裏設置監聽器，生命週期的問題。 其實咱們使用 Lifecycle 真正的理由是，Lifecycle(LifecycleRegistry)類幫咱們處理了大量的與宿主組件生命週期相關的問題，使咱們的代碼更簡潔。專心處理業務邏輯便可。

END

我是雷加,若是您喜歡個人文章，請留下你的贊;若有疑問和建議，請在評論區留言
個人Github,歡迎關注~

Jetpack 專欄：
Lifecycle：Jetpack系列 - Lifecycle從入門到源碼
ViewModel：Jetpack系列 - ViewModel從入門到源碼
LiveData：Jetpack系列 - LiveData從入門到源碼
Palette：Jetpack系列 - Palette 入門指南

--------------------------------------- The End

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程