轉(zhuǎn)載請標(biāo)明出處：https://blog.csdn.net/zhaoyanjun6/article/details/99695779
本文出自【趙彥軍的博客】

一、Lifecycle簡介

為什么要引進(jìn)Lifecycle？

我們在處理Activity或者Fragment組件的生命周期相關(guān)時，不可避免會遇到這樣的問題：

我們在Activity的onCreate()中初始化某些成員（比如MVP架構(gòu)中的Presenter，或者AudioManager、MediaPlayer等），然后在onStop中對這些成員進(jìn)行對應(yīng)處理，在onDestroy中釋放這些資源，這樣導(dǎo)致我們的代碼也許會像這樣：

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();} }

代碼沒有問題，關(guān)鍵問題是，實際生產(chǎn)環(huán)境中 ，這樣的代碼會非常復(fù)雜，你最終會有太多的類似調(diào)用并且會導(dǎo)致 onCreate()和 onDestroy()方法變的非常臃腫。

二、解決方案

Lifecycle 是一個類，它持有關(guān)于組件（如 Activity或 Fragment）生命周期狀態(tài)的信息，并且允許其他對象觀察此狀態(tài)。

第1步：BasePresenter 繼承 LifecycleObserver

open class BasePresenter : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)open fun onCreate(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_START)open fun onStart(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)open fun onResume(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)open fun onPause(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)open fun onStop(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)open fun onDestroy(owner: LifecycleOwner) {}@OnLifecycleEvent(Lifecycle.Event.ON_ANY)open fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {}}

第2步：MainPresenter 繼承 BasePresenter

class MyPresenter : BasePresenter() {override fun onCreate(owner: LifecycleOwner) {super.onCreate(owner)Log.e("Lifecycle", "onCreate")}override fun onStart(owner: LifecycleOwner) {super.onStart(owner)Log.e("Lifecycle", "onStart")}override fun onResume(owner: LifecycleOwner) {super.onResume(owner)Log.e("Lifecycle", "onResume")}override fun onPause(owner: LifecycleOwner) {super.onPause(owner)Log.e("Lifecycle", "onPause")}override fun onStop(owner: LifecycleOwner) {super.onStop(owner)Log.e("Lifecycle", "onStop")}override fun onDestroy(owner: LifecycleOwner) {super.onDestroy(owner)Log.e("Lifecycle", "onDestroy")}override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {super.onLifecycleChanged(owner, event)Log.e("Lifecycle", "onLifecycleChanged $event")}}

第4步：在Activity/Fragment容器中添加Observer

package com.yanjunimport android.os.Bundle import android.support.v7.app.AppCompatActivity import android.util.Logclass MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)lifecycle.addObserver(MainPresenter())}override fun onDestroy() {super.onDestroy()} }

如此，每當(dāng)Activity發(fā)生了對應(yīng)的生命周期改變，Presenter就會執(zhí)行對應(yīng)事件注解的方法：
除onCreate和onDestroy事件之外，Lifecycle一共提供了所有的生命周期事件，只要
通過注解進(jìn)行聲明，就能夠使LifecycleObserver觀察到對應(yīng)的生命周期事件：

//app進(jìn)入時 com.example.myapplication E/Lifecycle: onCreate com.example.myapplication E/Lifecycle: onLifecycleChanged ON_CREATE com.example.myapplication E/Lifecycle: onStart com.example.myapplication E/Lifecycle: onLifecycleChanged ON_START com.example.myapplication E/Lifecycle: onResume com.example.myapplication E/Lifecycle: onLifecycleChanged ON_RESUME//app退出時 com.example.myapplication E/Lifecycle: onPause com.example.myapplication E/Lifecycle: onLifecycleChanged ON_PAUSE com.example.myapplication E/Lifecycle: onStop com.example.myapplication E/Lifecycle: onLifecycleChanged ON_STOP com.example.myapplication E/Lifecycle: onDestroy com.example.myapplication E/Lifecycle: onLifecycleChanged ON_DESTROY

三、Lifecycle.Event

Lifecycle 是一個抽象類

public abstract class Lifecycle {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}public enum State {/*** Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch* any more events. For instance, for an {@link android.app.Activity}, this state is reached* <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.*/DESTROYED,/*** Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is* the state when it is constructed but has not received* {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.*/INITIALIZED,/*** Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state* is reached in two cases:* <ul>* <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;* <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.* </ul>*/CREATED,/*** Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state* is reached in two cases:* <ul>* <li>after {@link android.app.Activity#onStart() onStart} call;* <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.* </ul>*/STARTED,/*** Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state* is reached after {@link android.app.Activity#onResume() onResume} is called.*/RESUMED;/*** Compares if this State is greater or equal to the given {@code state}.** @param state State to compare with* @return true if this State is greater or equal to the given {@code state}*/public boolean isAtLeast(@NonNull State state) {return compareTo(state) >= 0;}} }

四、原理分析

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

• LifecycleObserver接口（ Lifecycle觀察者）：

實現(xiàn)該接口的類，通過注解的方式，可以通過被LifecycleOwner類的addObserver(LifecycleObserver o)方法注冊,被注冊后，LifecycleObserver便可以觀察到LifecycleOwner的生命周期事件。

• LifecycleOwner接口 Lifecycle持有者）：

實現(xiàn)該接口的類持有生命周期(Lifecycle對象)，該接口的生命周期(Lifecycle對象)的改變會被其注冊的觀察者LifecycleObserver觀察到并觸發(fā)其對應(yīng)的事件。

• Lifecycle(生命周期)：

和LifecycleOwner不同的是，LifecycleOwner本身持有Lifecycle對象，LifecycleOwner通過其Lifecycle getLifecycle()的接口獲取內(nèi)部Lifecycle對象。

• State(當(dāng)前生命周期所處狀態(tài))：如圖所示。

• Event(當(dāng)前生命周期改變對應(yīng)的事件)：

當(dāng)Lifecycle發(fā)生改變，如進(jìn)入onCreate,會自動發(fā)出ON_CREATE事件。

下面我們將換一種方式在Fragment 中實現(xiàn) Lifecycle 的功能，來探究它的內(nèi)部實現(xiàn)原理：

1、Fragment：LifecycleOwner

Fragment(Activity同理，我們 本文以Fragment為例，下同)：實現(xiàn)了LifecycleOwner接口，這意味著Fragment對象持有生命周期對象（Lifecycle），并可以通過Lifecycle getLifecycle()方法獲取內(nèi)部的Lifecycle對象：

public class Fragment implements xxx, LifecycleOwner {//...省略其他LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);@Overridepublic Lifecycle getLifecycle() {return mLifecycleRegistry;} }public interface LifecycleOwner {@NonNullLifecycle getLifecycle(); }

可以看到，實現(xiàn)的getLifecycle()方法，實際上返回的是 LifecycleRegistry 對象，LifecycleRegistry對象實際上繼承了 Lifecycle，這個下文再講。
持有Lifecycle有什么作用呢？實際上在Fragment對應(yīng)的生命周期內(nèi)，都會發(fā)送對應(yīng)的生命周期事件給內(nèi)部的 LifecycleRegistry對象處理：

public class Fragment implements xxx, LifecycleOwner {//...void performCreate(Bundle savedInstanceState) {onCreate(savedInstanceState); //1.先執(zhí)行生命周期方法//...省略代碼//2.生命周期事件分發(fā)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.注意，調(diào)用順序變了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內(nèi)部的Lifecycle對象（就是mLifecycleRegistry）還將生命周期對應(yīng)的事件作為參數(shù)傳給了 handleLifecycleEvent() 方法。

同時，你會發(fā)現(xiàn)Fragment中performCreate()、performStart()、performResume()會先調(diào)用自身的onXXX()方法，然后再調(diào)用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中會先LifecycleRegistry的handleLifecycleEvent()方法 ，然后調(diào)用自身的onXXX()方法。

FullLifecycleObserver

LifecycleObserver有一個子類是 ：FullLifecycleObserver ，下面我們看看它的實現(xiàn)：

package android.arch.lifecycle;interface FullLifecycleObserver extends LifecycleObserver {void onCreate(LifecycleOwner owner);void onStart(LifecycleOwner owner);void onResume(LifecycleOwner owner);void onPause(LifecycleOwner owner);void onStop(LifecycleOwner owner);void onDestroy(LifecycleOwner owner); }

不過可惜的是 FullLifecycleObserver 不是 public ， 我們也用不了。

參考資料

Android官方架構(gòu)組件Lifecycle:生命周期組件詳解&原理分析

總結(jié)

以上是生活随笔為你收集整理的Android Lifecycle 生命周期组件详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。