Android 架构组件之 Lifecycle-原创手记-慕课网

Lifecycle 是 Google 给出的架构组件之一，它能够感知具有生命周期的组件（如 Activity 和 Fragment）的生命周期变化。本文将从以下几个方面对 Lifecycle 进行介绍：

为什么要使用 Lifecycle？
分析 Lifecycle 的组成及实现原理；
总结一下 Lifecycle 的使用

1. 为什么要使用 Lifecycle？

Lifecycle 能够感知具有生命周期的组件（如 Activity 和 Fragment）的生命周期变化，
使用 Lifecycle 可以避免编写模板代码，同时生成组织性更好，更便于维护的代码。这是 Lifecycle 的特点，下面将从实际开发中的一个案例，来介绍为什么要使用 Lifecycle。

1.1 在 Lifecycle 出现之前，实现 Activity 与 Presenter 的绑定

我们经常见到在 Activity 和 Fragment 的生命周期中写一些业务相关的代码，这些代码通常组织性和可读性不高，维护起来也非常不方便。

这时候我们通常会用到 MVP 模式，将这些代码从相应的方法中剥离。比如我们会定义一个接口 IPresenter，在接口中定义一些生命周期相关的方法。

interface IPresenter {
    fun onCreate(savedInstanceState: Bundle?)
    fun onStart()
    fun onPause()
    fun onResume()
    fun onStop()
    fun onDestroy()
}

然后需要再定义一个类 MainPresenter，来实现 IPresenter 接口。

class MainPresenter :IPresenter{
    override fun onCreate() {
    }

    override fun onStart() {
    }

    override fun onPause() {
    }

    override fun onResume() {
    }

    override fun onStop() {
    }

    override fun onDestroy() {
    }
}

最后要在我们的 MainActivity 中的每个生命周期的回调方法中都要调用 IPresenter 中对应的方法。

class MainActivity : AppCompatActivity() {

    val presenter = MainPresenter()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        presenter.onCreate()
    }

    override fun onStart() {
        super.onStart()
        presenter.onStart()
    }

    override fun onResume() {
        super.onResume()
        presenter.onResume()
    }

    override fun onPause() {
        super.onPause()
        presenter.onPause()
    }

    override fun onStop() {
        super.onStop()
        presenter.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
        presenter.onDestroy()
    }
}

当然这只是一种最简单的方式，实现将 Activity 与 Presenter 绑定，当然我们可以把绑定的过程通过反射来实现，这样就避免了重复的绑定。

那有没有更优雅的方式呢，答案是 Lifecycle。我们来看一下，使用 Lifecycle 该如何实现将 Activity 与 Presenter 的绑定呢？

1.2 使用 Lifecycle 完成 Activity 与 Presenter 的绑定

首先让 MainPresenter 实现 DefaultLifecycleObserver 接口，这里可以根据需要去实现生命周期的方法。

class MainPresenter : DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Logger.d("onCreate...")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Logger.d("onStop...")
    }
}

然后在 MainActivity 中添加 MainPresenter 的实例，至此就完成了 Activity 与 Presenter 的绑定。

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.layout_lifecycle)

        val presenter = MainPresenter()
        lifecycle.addObserver(presenter)
    }
}

可以认为 Google 将我们以前通过 MVP 框架实现的 V 与 P 的绑定过程，放到了Android 的系统框架里，并且功能丰富。

2. 分析 Lifecycle 的组成及实现原理

分析框架的组成和实现原理，我习惯从类图开始，在绘制类图的过程中，会了解框架大概包含哪些组成部分，有哪些比较重要的成员变量和方法。

2.1 Lifecycle 在 Activity 中的使用

我们以上面的示例 MainActivity，看一下 MainActivity、LifecycleOwner、Lifecycle 和 LifecycleObserver 之间的类图。在类图中对 LifecycleOwner、Lifecycle 和 LifecycleObserver 进行了颜色的区分，方便理解。

看过上面的类图，我们总结一下：

Lifecycle 是一个抽象类，它有两个枚举类型的内部类 Event和 State，分别对应着事件类型和组件的状态；
LifecycleOwner 是一个接口，它有一个 getLifecycle()方法要子类去实现。
我们的 MainActivity 继承自 FragmentActivity，而 FragmentActivity 是 LifecycleOwner 的实现类。在 MainActivity 中 getLifecycle()方法返回的是 Lifecycle 的子类 LifecycleRegistry实例。
在 LifecycleRegistry 类中的静态内部类 ObserverWithState 持有LifecycleEventObserver 对象的实例，LifecycleEventObserver 是 LifecycleObserver 的子类。

至此，MainActivity、LifecycleOwner、Lifecycle 和 LifecycleObserver 就都关联了起来。

**但是这几个类之间通过怎样的调用关系，实现了对 Activity 生命周期的监听呢？**再来看一张时序图。

看过上面的时序图，我们可以总结一下：

在 MainActivity 中调用 getLifecycle()方法得到 LifecycleRegistry 对象，LifecycleRegistry 对象的初始化在 FragmentActivity 中完成。调用 addObserver()方法将 LifecycleObserver 的对象作为参数传递进去，这样就完成了一个完整的注册监听过程。
在 Activity 生命周期变化时，在每个生命周期回调函数中调用 LifecycleRegistry的 handleLifecycleEvent()方法，在 handleLifecycleEvent()方法的层层调用中，最后通过 observer.dispatchEvent(lifecycleOwner, event) 将生命周期的变化传递到 LifecycleObserver 的实现类MainPresenter 中。

这个过程，参考 LifecycleRegistry 中的 handleLifecycleEvent()方法的调用关系。

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

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;
        sync();
        mHandlingEvent = false;
    }

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            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;
    }
    
private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

2.2 Lifecycle 在 Fragment 中的使用

了解了在 Activity 中的实现过程，下面来看这个过程在 Fragment 中是怎样的。

看过类图，我们总结一下：

Fragment 继承了 LifecycleOwner 接口，getLifecycle()方法返回的是 Lifecycle 的子类 LifecycleRegistry实例。
同样的，在 LifecycleRegistry 类中的静态内部类 ObserverWithState 持有LifecycleEventObserver 对象，LifecycleEventObserver 是 LifecycleObserver 的子类。

**那 LifecyleObserver 的实现类又是怎样对 Fragment 的生命周期进行监听的呢？**给出时序图：

总结一下：

可以看到和对 Activity 生命周期监听过程是类似的，在 Fragment 中调用 getLifecycle()方法得到 LifecycleRegistry 对象,调用 addObserver()方法将实现了 LifecycleObserver 的对象作为参数传递进去，这样就完成了一个完整的注册监听过程。
在 Fragment 生命周期变化时，在每个生命周期回调函数中调用 LifecycleRegistry的 handleLifecycleEvent()方法。在 handleLifecycleEvent()方法的层层调用中，最后通过 observer.dispatchEvent(lifecycleOwner, event) 将生命周期的变化传递到 LifecycleObserver 的实现类中。区别于在 Activity中的过程，Fragment 中生命周期的方法会先调用 performXXX()方法。

3. 总结一下 Lifecycle 的使用

介绍完 Lifecycle 的原理，最后来总结一下 Lifecyle 的使用：

1. 首先导入 Lifecycle 的依赖，Lifecycle 有很多依赖包，可以根据需要进行导入。

2.创建 LifecycleObserver 的实现类。
从上面的类图关系中可以看到，跟 LifecycleObserver 有关的接口有4个，分别是 LifecycleObserver、FullLifecycleObserver、DefaultLifecycleObserver 和LifecycleEventObserver。其中 FullLifecycleObserver 是一个包级别的接口，我们没有办法直接使用。所以实现 LifecycleObserver 就有三种方式。

方式一，实现 DefaultLifecycleObserver 接口，然后重现接口中与生命周期有关的方法；

class MainPresenter : DefaultLifecycleObserver{

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Logger.d("onCreate...")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Logger.d("onStop...")
    }
}

方式二，实现 LifecycleObserver 接口，然后通过注解的方式来监听生命周期的变化；

class MainPresenter : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        Logger.d("onCreate...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        Logger.d("onStart...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Logger.d("onResume...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        Logger.d("onPause...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        Logger.d("onStop...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        Logger.d("onDestroy...")
    }
}

方式三，实现 LifecycleEventObserver接口，在onStateChanged()方法中来处理不同类型的Event 类型。

class MainPresenter : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Event) {
        when (event) {
            Event.ON_CREATE,
            Event.ON_START,
            Event.ON_RESUME,
            Event.ON_PAUSE,
            Event.ON_STOP,
            Event.ON_DESTROY -> Logger.d("onStateChanged...${event.name}")
        }
    }
}

3. 实现了 LifecycleObserver 接口之后，接下来调用 addObserver()方法添加我们的观察者，完成对生命周期的监听。

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.layout_lifecycle)

        val presenter = MainPresenter()
        lifecycle.addObserver(presenter)
    }
}

到这里，我们就对架构组件 Lifecycle 的介绍就结束了，下一篇，来介绍架构组件中的 LiveData。

参考链接

Lifecycle-Aware Components
Android 架构组件
 了解 Activity 生命周期
 Handling Lifecycles with Lifecycle-Aware Components