Android架构灵魂组件Lifecycle的生命周期机制详解

前言：写作就跟生活一样，是一趟发现之旅。

前言

在早期 Andorid 架构中，生命周期的事件监听和状态查询，我们需要自定义一套提供侦测功能的 Activity/Fragment 基类及回调接口，在 Activity/Fragment 的生命周期方法中实现依赖组件的操作，在外部进行事件监听和状态查询。这种模式会导致代码条理性很差而且会扩散错误。

在 Lifecycle 引入后，可以避免在 Activity/Fragment 生命周期方法内写太多的业务逻辑处理代码，这样可以使我们的业务逻辑更加解耦。有助于您编写出更有条理且往往更精简的代码，此类代码更易于维护。

什么是Lifecycle

Lifecycle 是一个具备宿主生命周期感知能力的组件。它持有组件（Activity/Fragment）生命周期状态信息，并且允许其观察者监听宿主生命周期状态变化。

一、Lifecycle的使用

在 build.gradle 文件中添加依赖：

implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1"
implementation "androidx.lifecycle:lifecycle-common:2.5.1"

使用 Lifecycle 观察宿主状态有三种实现方式。

1.继承LifecycleObserver

第一种是实现 LifecycleObserver 接口，采用注解方式，使用 @OnLifecycleEvent 标记自定义的方法以实现回调。

//1.自定义LifecycleObserver观察者，用注解声明每个方法观察宿主的状态
public class MyLifecycleObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NotNull LifecycleOwner owner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(@NotNull LifecycleOwner owner) {

    }
}

//2.宿主中注册观察者，观察宿主生命周期状态变化
class MyFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        MyLifecycleObserver observer = new MyLifecycleObserver();
        getLifecycle().addObserver(observer);
    }
}

实现 LifecycleObserver 接口，只需要在指定方法上面标记注解，来观察宿主的生命周期，注解里面标记着生命周期事件类型就可以了。然后在宿主注册这个 LifecycleObserver，它不需要销毁的时候进行反注册。

2.实现DefaultLifecycleObserver接口

第二种方式：定义一个类，实现 DefaultLifecycleObserver 接口，里面提供了完整的生命周期事件，为所有的生命周期事件都定义了对应的回调方法。它实现了 FullLifecycleObserver 接口，使用了 default 关键字空实现了各个方法。

class MyFullLifeObserver : DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {}

    override fun onStart(owner: LifecycleOwner) {}

    override fun onResume(owner: LifecycleOwner) {}

    override fun onPause(owner: LifecycleOwner) {}

    override fun onStop(owner: LifecycleOwner) {}

    override fun onDestroy(owner: LifecycleOwner) {}
}

使用 DefaultLifecycleObserver 后，就需要把注解实现相关逻辑移除。即使保留注解，由于 Lifecycling 的处理逻辑（系统架构逻辑中所有传入的观察者都会经过 Lifecycling 处理，下面会讲解到），任何 FullLifecycleObserver 的实现类 (即包括DefaultLifecycleObserver) 内部所有的 @OnLifecycleEvent 注解都会失效。

3.实现LifecycleEventObserver

第三种方式：实现 LifecycleEventObserver，它是 LifecycleObserver 的子接口。只有一个 onStateChanged 方法，以 Lifecycle.Event 入参提供事件区分的形式，进行统一方法回调。

interface LifecycleEventObserver : LifecycleObserver {
    // 宿主生命周期变化的事件都会通知到这个方法
    fun onStateChanged(owner: LifecycleOwner?, event: Lifecycle.Event?)
}

//继承自LifecycleEventObserver，复写onStateChanged方法
class MyLifecycleEventObserver : LifecycleEventObserver {
    override fun onStateChanged(owner: LifecycleOwner?, event: Lifecycle.Event?) {
        //需要自行判断Event是onStart还是onStop
    }
}

无论哪一种方法都需要在宿主中注册观察者。推荐使用第二种和第三种方式，第一种不推荐使用。

二、Lifecycle 组件架构

为下面更好深入理解原理，我们先来简单了解下 Lifecycle 组件中几个重要的类：

• Lifecycle(生命周期) ：一个核心抽象类，用于存储有关组件（如 activity/fragment 的生命周期状态的信息，并允许其他对象观察此状态。继承该类的子类，表示本身是一个 具有Android生命周期特性 的对象。

• LifecycleOwner：核心接口，Lifecycle 持有者，该接口的实现类表示能够为外部提供Lifecycle实例。具有 Android 生命周期的类。这些事件可以被自定义组件用来处理生命周期的变化，而不需要在 Activity/Fragment 中实现任何代码。

• LifecycleRegistry：核心类，Lifecycle 的实现类，可以处理多个观察者。实现 Lifecycle 定义生命周期观察订阅，生命周期查询的方法。还实现了架构中，生命周期变化时触发的自身状态处理和相关对观察者的订阅回调的逻辑。

• LifecycleObserver：观察者，将一个类标记为生命周期观察者。实现该接口的类，通过注解的方式，可以通过被 LifecycleOwner 类的 addObserver() 方法注册，LifecycleObserver 便可以观察到 LifecycleOwner 的生命周期事件。

• State ：当前生命周期所处的状态。

• Event ：当前生命周期改变对应的事件。从框架和 Lifecycle 类分派的生命周期事件。这些事件对应到 activity/fragment 中的回调事件。

LifecyclerOwner、Lifecycle、LifecyleRegistry 和 Observer 的关系如下图：

一般来说宿主代表着 Activity/Fragment，都实现了 LifecyclerOwner 接口；那么每个宿主必须复写 getLifecycle()，并且返回一个 Lifecycle 对象，这个 Lifecycle 对象实际上是LifecycleRegistry，只不过它采用的是面向接口的编程方式，我们对 LifecycleRegistry 注册 Observer 的时候，可以是 LifecycleObserver，FullLifecyclerOberver，LifecyclerEventObserver。

三、Lifecycle 原理剖析

系统框架中，LifecycleOwner 接口的实现类为 ComponentActivity 和 Fragment，两者提供的 Lifecycle 对象，是系统框架实现中 Lifecycle 的唯一子类 LifecycleRegistry。

1.Fragment是如何实现Lifecycle的

public class Fragment implements LifecycleOwner {
    // 创建LifecycleRegistry 并且把this传递进去
    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public Lifecycle getLifecycle() {
        //2.复写自LifecycleOwner,所以必须new LifecycleRegistry对象返回
        return mLifecycleRegistry;
    }
    //······
}

Fragment 内 Lifecycle 核心代码片段，实现了 LifecycleOwner 接口，它表示生命周期宿主，持有生命周期(Lifecycle对象)，该接口的生命周期的改变会被其注册的观察者 LifecycleObserver 观察到并触发其对应的事件。

必须复写 getLifecycle() 这个方法，返回的实际是 mLifecycleRegistry，说明 Lifecycle 是 LifecycleRegistry 的父类，这是一种面向接口的编程思想。

public class Fragment implements LifecycleOwner {
    //······
    void performCreate(Bundle savedInstanceState) {
        //······
        onCreate(savedInstanceState);
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

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

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

    void performPause() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }

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

    void performDestroy() {
        mChildFragmentManager.dispatchDestroy();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        //······
     }
}

我们注册 Lifecycle 的时候，实际上都注册到 LifecycleRegistry 里面去了。通过 handleLifecycleEvent() 分发自己的状态到每个观察者，从而实现观察生命周期实现变化的能力。看起来简单实际上 Lifecycle 在分发生命周期的时候并不简单，所有逻辑重点都在 LifecycleRegistry。

Fragment 是如何派发生命周期的？也就是它会在自己生命周期里面，让 LifecycleRegistry 去分发生命周期事件，给每一个观察者。但是 Activity 中并不是这么做的。

2.Activity是如何是实现Lifecycle的

Activity 实现 Lifecycle 的核心源码，需要来到 ComponentActivity 里面，同样也是实现了 LifecycleOwner 接口：

public class ComponentActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    //复写getLifecycle()，返回LifecycleRegistry对象
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //往Activity上添加一个fragment，用以报告生命周期的变化
        //目的是为了兼顾不是继承自AppCompactActivity的场景
        ReportFragment.injectIfNeededIn(this);
    }
}

与上面 Fragment 的实现类似，它实现了 LifecycleOwner，表示一个生命周期的宿主，必须实现 getLifecycle() 方法，返回一个 Lifecycle，也就是 LifecycleRegistry