theme: smartblue

開啟掘金成長之旅！這是我參與「掘金日新計劃 · 12 月更文挑戰」的第3天，點選檢視活動詳情

前言

Lifecycle 到現在大家應該都很熟悉了，是 Jetpack 中管理生命週期的一個工具。除了 Activity、Fragment 中能夠提供給我們生命週期回撥，任何自定義 View 同樣可以實現類似的回撥功能。在沒有 Lifecycle 之前我們都需要定義介面，手動在生命週期方法中呼叫介面的實現。而 Lifecycle 僅僅需要一行程式碼即可實現！對於我們來說不僅應該學會使用 Lifecycle 更應該瞭解其原理，學習其優秀的設計。那麼本文就來淺析一下 Lifecycle 的原理，看看 Google 官方是如何對生命週期回撥這個需求進行設計。

原始碼版本

// lifecycle 的擴充套件很多這裡用 * 代替了 implementation androidx.lifecycle:lifecycle-*:2.4.0

2.4 相對於 2.3 版本將 @OnLifecycleEvent 註解標記了廢棄，因為其使用了反射效能不佳，這塊我們下面再說。

簡單使用

Lifecycle 使用起來非常簡單，以給 Activity 增加生命週期回撥為例，新建回撥類 ActivityLifecycleObserver：

ActivityLifecycleObserver.kt ```kotlin class ActivityLifecycleObserver: DefaultLifecycleObserver {

private val TAG = "LifecycleObserver"

override fun onCreate(owner: LifecycleOwner) {
    super.onCreate(owner)
    Log.d(TAG, "onCreate")
}

override fun onStart(owner: LifecycleOwner) {
    super.onStart(owner)
    Log.d(TAG, "onStart")
}

override fun onResume(owner: LifecycleOwner) {
    super.onResume(owner)
    Log.d(TAG, "onResume")
}

override fun onPause(owner: LifecycleOwner) {
    super.onPause(owner)
    Log.d(TAG, "onPause")
}

override fun onStop(owner: LifecycleOwner) {
    super.onStop(owner)
    Log.d(TAG, "onStop")
}

override fun onDestroy(owner: LifecycleOwner) {
    super.onDestroy(owner)
    Log.d(TAG, "onDestroy")
}

} ```

在 Activity 中新增一行程式碼：

kotlin class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { // ... // 一行程式碼搞定 lifecycle.addObserver(ActivityLifecycleObserver()) } } 效果：

原始碼分析

原理探究

Lifecycle 不是魔法，只是一種優秀的設計，既然可以在對應的生命週期中觸發回撥那麼其生命週期方法中肯定有相關程式碼呼叫，順著這個想法翻一下 Activity 的原始碼，果不其然，在 ComponentActivity 的 onCreate 中就找到了線索：

ComponentActivity.java java // 繼承關係只貼出了關鍵資訊 // ComponentActivity 實現了 LifecycleOwner 介面 public class ComponentActivity implements LifecycleOwner{ @Override protected void onCreate(@Nullable Bundle savedInstanceState) { // ... ReportFragment.injectIfNeededIn(this); // ... } } ReportFragment.injectIfNeededIn 點進去檢視其原始碼： ```java public class ReportFragment extends android.app.Fragment { // ... public static void injectIfNeededIn(Activity activity) { // sdk >= 29 則使用 Application.ActivityLifecycleCallbacks 來處理 activity 的生命週期回撥 if (Build.VERSION.SDK_INT >= 29) { LifecycleCallbacks.registerIn(activity); }

    // sdk 小於 29 的相容處理
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        // 給 activity 新增一個空白的 Fragment 並且設定 TAG
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
}

// 通過固定 TAG 獲取當前 activity 中的空白 Fragment
static ReportFragment get(Activity activity) {
    return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
            REPORT_FRAGMENT_TAG);
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    // 所有的生命週期方法中都呼叫了 dispatch
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    super.onStart();
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
    super.onResume();
    dispatch(Lifecycle.Event.ON_RESUME);
}

@Override
public void onPause() {
    super.onPause();
    dispatch(Lifecycle.Event.ON_PAUSE);
}

@Override
public void onStop() {
    super.onStop();
    dispatch(Lifecycle.Event.ON_STOP);
}

@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
}

// 內部呼叫了 雙引數 dispatch 方法
private void dispatch(@NonNull Lifecycle.Event event) {
    // sdk >= 29 時利用 LifecycleCallbacks 中的回撥直接呼叫雙引數 dispatch 方法
    if (Build.VERSION.SDK_INT < 29) {
        dispatch(getActivity(), event);
    }
}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    // ...
    // activity 一定要先實現 LifecycleOwner
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // 呼叫 handleLifecycleEvent
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity,
            @Nullable Bundle bundle) {
    }

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
            @Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }
    // 其他的生命週期回撥和 onCreate 是一樣的都是呼叫 dispatch 就不全貼了...
}
// ...

} ```

ReportFragment 的原始碼很簡單，可以看出通過呼叫 injectIfNeededIn 會給 Activity 新增一個空白的 Fragment，當 Activity 生命週期發生變化時 Fragment 中會觸發對應的生命週期，在 Fragment 的生命週期方法中呼叫 dispatch 傳遞生命週期階段。這個辦法和圖片載入庫 Glide 中的設計有異曲同工之妙，關於 Glide 系列的部落格後續會隨緣寫寫。

Google 對程式碼相容處理也非常不錯，sdk >=29 時直接使用了更為方便的 Application 的ActivityLifecycleCallbacks 在其對應方法中呼叫 dispatch，這個 dispatch 中主要呼叫了 LifecycleRegistry 的 handleLifecycleEvent 方法。對於這部分我們先按下不表。

到這裡可以看出 Lifecycle 對於 Activity 來說是通過新增 Fragment 來處理生命週期回撥的。

初始化工作

我在學習 Lifecycle 到這部分時產生了一個想法，ReportFragment 既然是在 ComponentActivity 中新增的，我偏不按照官方的來，我不繼承 ComponentActivity 這種情況是不是就無法觸發回調了？先說答案：Google 官方給你治的明明白白的，依然會給你的 Activity 新增 ReportFragment。

修改 MainActivity 如下： ```kotlin class MainActivity : Activity(), LifecycleOwner {

val mLifecycle = LifecycleRegistry(this)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    getLifecycle().addObserver(ActivityLifecycleObserver())
}

override fun getLifecycle(): Lifecycle = mLifecycle

} ``` 這麼寫會發現 log 依舊正常輸出，這裡就不賣關子了直接給出結論，不過不能按照 2.4.0 版本來講了這部分的程式碼改動比較大 2.4.0 版本的這部分內容牽扯到了另一個庫 starup。所以這一小節的內容以 Lifecycle 2.2.0 版本來講，原理肯定是差不多的，重在理解原理。

在 lifecycle-process:2.2.0 原始碼中有一個 ContentProvider 原始碼如下： public class ProcessLifecycleOwnerInitializer extends ContentProvider { @Override public boolean onCreate() { // 注意這一行 LifecycleDispatcher.init(getContext()); // ... } } 繼續檢視其原始碼： ``` class LifecycleDispatcher {

private static AtomicBoolean sInitialized = new AtomicBoolean(false);

static void init(Context context) {
    if (sInitialized.getAndSet(true)) {
        return;
    }
    // 又看到了熟悉的 registerActivityLifecycleCallbacks
    ((Application) context.getApplicationContext())
            .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}

// DispatcherActivityCallback 原始碼也非常簡單
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        // 這裡藉助 Application.ActivityLifecycleCallbacks 又對 Activity 添加了 ReportFragment
        ReportFragment.injectIfNeededIn(activity);
    }

    @Override
    public void onActivityStopped(Activity activity) {
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
    }
}

private LifecycleDispatcher() {
}

} ```

Google 官方一個 ContentProvider 已然看穿我的小九九，專門防止有些開發者不繼承 ComponentActivity 特意在 ContentProvider 中又進行了一次注入空白 Fragment 操作，當然這個操作也不會重複，因為在新增 Fragment 前就先通過 TAG 獲取了一次，為 null 時才會進行新增。

兩個重要列舉類

先貼一張網圖：

Event 和 State 是兩個列舉類，其中的列舉型別是對應狀態，如圖所示 Event 的 ON_CREATE 對應的 State 即為 CREATED，以此類推。

在下面理解兩個類的原始碼時一定要結合這張圖。

Lifecycle.Event

```java public enum Event { // ON_XXX 是 Event 定義的幾種生命週期，可以參考 Activity 的生命週期來理解 // Lifecycle 不僅僅是給 Activity 用，可以讓任何類都有生命週期，並且觸發回撥 ON_CREATE,

ON_START,

ON_RESUME,

ON_PAUSE,

ON_STOP,

ON_DESTROY,

ON_ANY;

// downFrom downTo upFrom upTo 分別是四個根據 State 獲取 Evnent 的方法
public static Event downFrom(@NonNull State state) {
    switch (state) {
        case CREATED:
            return ON_DESTROY;
        case STARTED:
            return ON_STOP;
        case RESUMED:
            return ON_PAUSE;
        default:
            return null;
    }
}

public static Event downTo(@NonNull State state) {
    switch (state) {
        case DESTROYED:
            return ON_DESTROY;
        case CREATED:
            return ON_STOP;
        case STARTED:
            return ON_PAUSE;
        default:
            return null;
    }
}

public static Event upFrom(@NonNull State state) {
    switch (state) {
        case INITIALIZED:
            return ON_CREATE;
        case CREATED:
            return ON_START;
        case STARTED:
            return ON_RESUME;
        default:
            return null;
    }
}

public static Event upTo(@NonNull State state) {
    switch (state) {
        case CREATED:
            return ON_CREATE;
        case STARTED:
            return ON_START;
        case RESUMED:
            return ON_RESUME;
        default:
            return null;
    }
}

// 根據當前 Event 獲取當前對應的 State
public State getTargetState() {
    switch (this) {
        case ON_CREATE:
        case ON_STOP:
            return State.CREATED;
        case ON_START:
        case ON_PAUSE:
            return State.STARTED;
        case ON_RESUME:
            return State.RESUMED;
        case ON_DESTROY:
            return State.DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException(this + " has no target state");
}

} ```

Lifecycle.State

```java public enum State { // State 就是狀態的意思，表示當前物件的生命週期處於什麼樣的狀態 DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;

// 比較 宣告的順序進行比較
public boolean isAtLeast(@NonNull State state) {
    return compareTo(state) >= 0;
}

} ```

列舉類的程式碼比較簡單，結合圖片去理解 Event 中的升降操作方法也很簡單，就不贅述了。

LifecycleRegistry

在上述 RepoFragment 中 dispatch 方法可謂是核心程式碼，dispatch 方法中呼叫了 LifecycleRegistry 的 handleLifecycleEvent，先來看看 LifecycleRegistry 是什麼，LifecycleRegistry 繼承自 Lifecycle 原始碼如下：

LifecycleRegistry.java ```java public class LifecycleRegistry extends Lifecycle {

// 我們呼叫 addObserver 時就將物件新增到了這個 map 中
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
        new FastSafeIterableMap<>();
// 當前狀態
private State mState;
// 弱引用儲存當前要監聽的物件
private final WeakReference<LifecycleOwner> mLifecycleOwner;
//...

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
    this(provider, true);
}

// 建構函式
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
    // 儲存當前被觀察的物件
    mLifecycleOwner = new WeakReference<>(provider);
    // 狀態初始為 INITIALIZED
    mState = INITIALIZED;
    // 預設為 true，執行在主執行緒
    mEnforceMainThread = enforceMainThread;
}

// 新增觀察者
public void addObserver(@NonNull LifecycleObserver observer) {
    // mEnforceMainThread 為ture時 判斷是否為主執行緒
    // 內部通過 Handler 判斷的
    enforceMainThreadIfNeeded("addObserver");
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // 傳入的 Observer 包裝為 ObserverWithState
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    // 新增到 map 中，第一次新增返回 null，後續新增返回 map 中的 value
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    // 第一次新增 為null 不進入 if
    if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }

    // 是否重複進入
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    // ++ 操作進行標記 操作完成後進行 -- 
    mAddingObserverCounter++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        final Event event = Event.upFrom(statefulObserver.mState);
        if (event == null) {
            throw new IllegalStateException("no event up from " + statefulObserver.mState);
        }
        statefulObserver.dispatchEvent(lifecycleOwner, event);
        popParentState();
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // 進行同步 將所有的 observer state event 保持一致
        sync();
    }
    mAddingObserverCounter--;
}

// 在 RepoFragment 生命週期中呼叫的方法
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    // 內部呼叫了 moveToState
    moveToState(event.getTargetState());
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    // 和 addObserver 時一樣進行同步
    // 這裡是外部呼叫 handleLifecycleEvent 導致 event 發生變化進行同步
    sync();
    mHandlingEvent = false;
}

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        // isSynced 判斷 map （連結串列結構） 第一個元素和最後一個元素的 state 以及當前的 state 是否相同
    while (!isSynced()) {
        mNewEventOccurred = false;
        // 不同的話 則根據大小不同調用 backwardPass、forwardPass 進行同步
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 重點
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            // 重點
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

private void forwardPass(LifecycleOwner lifecycleOwner) {
    // ...
    // 迴圈呼叫每一個 observer 的 dispatchEvent
    // 也就是 ObserverWithState
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
            //...
            observer.dispatchEvent(lifecycleOwner, event);
            //...
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    // ...
    // 迴圈呼叫每一個 observer 的 dispatchEvent
    // 也就是 ObserverWithState
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
            //...
            observer.dispatchEvent(lifecycleOwner, event);
            //...
        }
    }
}

// ...

} `` 可以看出 LifecycleRegistry 內部維護了一個` 型別的 map，並且將 map 搞成了一個連結串列結構來存放我們傳入的 observer；ObserverWithState 是對我們傳入的 observer 的包裝類，當外部呼叫 handleLifecycleEvent 傳入的 Event 和當前對應的 State 不同時，就會進行同步，遍歷連結串列觸發 ObserverWithState 的 dispatchEvent 方法。

LifecycleRegistry 並沒有直接觸發生命週期回撥的操作，具體操作就在 ObserverWithState 類中。

ObserverWithState

ObserverWithState 是 LifecycleRegistry 的內部類，其原始碼如下：

```java static class ObserverWithState { State mState; LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {
    // 注意這一行程式碼
    mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
    mState = initialState;
}

void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = event.getTargetState();
    mState = min(mState, newState);
    // 這裡就是觸發回撥的具體方法了
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
}

} ```

ObserverWithState 的原始碼很少，重點就在於其中的 mLifecycleObserver 的初始化。檢視 Lifecycling.lifecycleEventObserver 方法原始碼： ```java static LifecycleEventObserver lifecycleEventObserver(Object object) {

// 前面這部分對應了文章開頭所說的 廢棄了 @OnLifecycleEvent 註解
// 推薦我們的 observer 都繼承 FullLifecycleObserver 
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
    // 如果繼承自 FullLifecycleObserver 那麼直接返回 FullLifecycleObserverAdapter
    // FullLifecycleObserverAdapter 內部的 onStateChange 方法直接根據當前 Event 觸發了對應的生命週期回撥方法
    // 我們繼承 FullLifecycleObserver 介面實現其方法即可
    // 這裡主要是避免了反射呼叫 提高效能 原始碼很簡單 點進去一看便知 就不貼了
    return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
            (LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
    return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}

if (isLifecycleEventObserver) {
    return (LifecycleEventObserver) object;
}

// 沒有繼承 FullLifecycleObserver 的處理 也就是 2.4.0 版本之前的註解處理
final Class<?> klass = object.getClass();
// 重點程式碼 下面再分析
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
    // 這個 if 表示存在和上述 FullLifecycleObserverAdapter 類似的 adapter 
    // 僅僅利用建構函式反射建立 adapter
    // ...
    return new CompositeGeneratedAdaptersObserver(adapters);
}
// 表示根據 @OnLifecycleEvent 註解反射對應方法進行呼叫
return new ReflectiveGenericLifecycleObserver(object);

} ``` 可以看出 lifecycleEventObserver 方法主要根據傳入的 observer 進行了不同的處理，使用 adapter 介面卡觸發回撥的程式碼比較簡單，大家自行檢視不難理解。通過 @OnLifecycleEvent 註解反射方法呼叫的情況應該目前使用的比較多，這裡就著重分析下這種情況。

@OnLifecycleEvent 註解回撥原理

getObserverConstructorType

從上面說到的一處重點方法開始分析，getObserverConstructorType 原始碼如下： java private static int getObserverConstructorType(Class<?> klass) { // 這裡用 map 做了一層快取提高效能 Integer callbackCache = sCallbackCache.get(klass); if (callbackCache != null) { return callbackCache; } // 重點在於 resolveObserverCallbackType int type = resolveObserverCallbackType(klass); sCallbackCache.put(klass, type); return type; } resolveObserverCallbackType 原始碼如下： ```java private static int resolveObserverCallbackType(Class<?> klass) { // 根據命名也不難看出 // REFLECTIVE_CALLBACK 表示需要反射呼叫 // GENERATED_CALLBACK 表示生成也就是生成 adapter if (klass.getCanonicalName() == null) { return REFLECTIVE_CALLBACK; }

// 這裡的 generatedConstructor 內部有生成 adapter 構造的邏輯 這裡就不具體分析了
Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
if (constructor != null) {
    sClassToAdapters.put(klass, Collections
            .<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
    return GENERATED_CALLBACK;
}

// 重點看註解反射 這種情況
boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
if (hasLifecycleMethods) {
    return REFLECTIVE_CALLBACK;
}

// ...

} 通過 hasLifecycleMethods 方法獲取是否存在 LifecycleMethods ，其原始碼如下：java boolean hasLifecycleMethods(Class<?> klass) { // 同樣做了一層 map 快取 Boolean hasLifecycleMethods = mHasLifecycleMethods.get(klass); if (hasLifecycleMethods != null) { return hasLifecycleMethods; } // 獲取類中的方法 Method[] methods = getDeclaredMethods(klass); // 遍歷 for (Method method : methods) { // 嘗試獲取 @OnLifecycleEvent 註解 OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class); if (annotation != null) { // 存在註解則說明是生命週期回撥方法 createInfo(klass, methods); return true; } } mHasLifecycleMethods.put(klass, false); return false; }

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) { Class<?> superclass = klass.getSuperclass(); Map handlerToEvent = new HashMap<>(); if (superclass != null) { // 這裡同樣又是 map 快取 CallbackInfo superInfo = getInfo(superclass); if (superInfo != null) { handlerToEvent.putAll(superInfo.mHandlerToEvent); } }

Class<?>[] interfaces = klass.getInterfaces();
for (Class<?> intrfc : interfaces) {
    for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
            intrfc).mHandlerToEvent.entrySet()) {
        verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
    }
}

// 再次獲取類中的 方法
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
    // 遍歷嘗試獲取 @OnLifecycleEvent 註解
    OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
    if (annotation == null) {
        continue;
    }
    hasLifecycleMethods = true;
    Class<?>[] params = method.getParameterTypes();
    int callType = CALL_TYPE_NO_ARG;
    if (params.length > 0) {
        callType = CALL_TYPE_PROVIDER;
        if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
            throw new IllegalArgumentException(
                    "invalid parameter type. Must be one and instanceof LifecycleOwner");
        }
    }
    // 獲取 @OnLifecycleEvent 註解中的 value
    Lifecycle.Event event = annotation.value();
    // ...
    // 生成 method 包裝類 callType 表示引數個數
    MethodReference methodReference = new MethodReference(callType, method);
    // 放入到 handlerToEvent map 容器中
    verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
}
// 對 handlerToEvent 進行包裝
CallbackInfo info = new CallbackInfo(handlerToEvent);
// 放入 map 快取
mCallbackMap.put(klass, info);
// class 是否存在生命週期回撥方法 map 快取
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;

} ``` 可以看出通過 getObserverConstructorType 獲取 observer 回撥型別時還額外對 observer 進行了解析，將標有 @OnLifecycleEvent 註解的方法進行了包裝，存入了 map 中；

ReflectiveGenericLifecycleObserver

通過上述的分析，如果使用 @OnLifecycleEvent 註解處理生命週期回撥，則 ObserverWithState 中的 mLifecycleObserver 最終生成的為 ReflectiveGenericLifecycleObserver；

我們再看一下其 onStateChanged 方法如何實現的： ```java class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver { // mWrapped 即為我們傳入的 observer private final Object mWrapped; // mInfo 即為上一小節中 createInfo 建立的 private final androidx.lifecycle.ClassesInfoCache.CallbackInfo mInfo;

ReflectiveGenericLifecycleObserver(Object wrapped) {
    mWrapped = wrapped;
    // 通過 map 獲取 mInfo
    // 如果不存在 會再走一次 createInfo 流程
    mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}

@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
    mInfo.invokeCallbacks(source, event, mWrapped);
}

} ```

最終又調回到了 CallbackInfo 中的 invokeCallbacks，檢視其原始碼： ```java static class CallbackInfo { final Map> mEventToHandlers; final Map mHandlerToEvent;

CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
    mHandlerToEvent = handlerToEvent;
    mEventToHandlers = new HashMap<>();
    // 對 mEventToHandlers 初始化
    for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
        Lifecycle.Event event = entry.getValue();
        List<MethodReference> methodReferences = mEventToHandlers.get(event);
        if (methodReferences == null) {
            methodReferences = new ArrayList<>();
            mEventToHandlers.put(event, methodReferences);
        }
        methodReferences.add(entry.getKey());
    }
}

void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
    // 最終呼叫到 invokeMethodsForEvent 中
    invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event, target);
}

private static void invokeMethodsForEvent(List<MethodReference> handlers, LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
    if (handlers != null) {
        for (int i = handlers.size() - 1; i >= 0; i--) {
            // 又呼叫到了 MethodReference 的 invokeCallback
            handlers.get(i).invokeCallback(source, event, mWrapped);
        }
    }
}

} 繼續跟著原始碼往裡跳，檢視 MethodReference 的 invokeCallback 的原始碼： // mMethod 即為 observer 中的回撥方法 final Method mMethod;

void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) { try { // 根據引數不同對 mMethod 進行反射呼叫 switch (mCallType) { case CALL_TYPE_NO_ARG: mMethod.invoke(target); break; case CALL_TYPE_PROVIDER: mMethod.invoke(target, source); break; case CALL_TYPE_PROVIDER_WITH_EVENT: mMethod.invoke(target, source, event); break; } } // ... } ``` 到此位置，就成功觸發了 observer 中對應註解中的回撥方法。

總結

最初版本的 Lifecycle 都使用 @OnLifecycleEvent 註解對 observer 中的方法進行標記，達到生命週期回撥的目的，2.4.0 提供了 FullLifecycleObserver 根據 Event 不同直接呼叫對應的方法，省去了反射方法、進行快取的步驟，提高了整體效能。其中用到了介面卡設計模式來實現，非常值得我們開發中借鑑。

在專案中可以能會有大量的 observer 需要解析，Lifecycle 中多處用到了 map 快取，足可見其重要性，對重複大量的操作做快取也是非常值得我們開發中借鑑。

Lifecycle 並不僅僅限於使用在 Activity 上，任何類實現 LifecycleOwner 都可以被 LifecycleObserver 觀察其生命週期，不過 Activity 是 Google 官方幫我添加了 RepoFragment 主動觸發了生命週期回撥，而對於我們自己寫的類而言需要在合適的時機主動觸發 onStateChanged 方法。

換個思路來想我們不僅僅可以讓任何類實現 LifecycleOwner 也可以讓任何類成為 LifecycleObserver，舉個例子，你有一個 WebView 想讓它跟隨 Activity 的生命週期進行自動銷燬，那麼 Activity 作為 LifecycleOwner，WebView 可以作為 LifecycleObserver。這個例子就不在這裡贅述了，歡迎檢視我之前的部落格關於 WebView 優化的兩篇部落格中對這部分的實現有具體的程式碼。

最後

如果我的部落格分享對你有點幫助，不妨點個贊支援下！

Android 原始碼淺析：Jetpack 元件 —— Lifecycle

theme: smartblue

前言

原始碼版本

簡單使用

原始碼分析

原理探究

初始化工作

兩個重要列舉類

Lifecycle.Event

Lifecycle.State

LifecycleRegistry

ObserverWithState

@OnLifecycleEvent 註解回撥原理

getObserverConstructorType

ReflectiveGenericLifecycleObserver

總結

最後