Android Jetpack组件Lifecycle基本使用和原理分析

本文主要对 Jetpack 的 Android Architecture Components 中的 Lifecycle 进行分析，首先会说明什么是 Lifecycle，然后通过一个实际的例子，来验证 Lifecycle 的特性，然后抛出问题，为啥 Lifecycle 这么厉害，这么强大！最后通过阅读Lifecycle 的源码，来一步一步解答疑问！

1.Lifecycle简介

什么是Lifecycle

Lifecycle提供了可用于构建生命周期感知型组件的类和接口，可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。

一句话：可以感知 Activity/Fragment 的生命周期并且可以在相应的回调事件中处理，非常方便

这样 Lifecycle 库能有效的避免内存泄漏和解决常见的 Android 生命周期难题！

2.Lifecycle基本用法

假设我们有一这样的需求：我们想提供一个接口可以感知Activity的生命周期，并且实现回调！用 Lifecycle 是怎么实现的？

2.1.定义ILifecycleObserver接口

首先我们定义一个接口去实现 LifecycleObserver，然后定义方法，用上OnLifecycleEvent注解。

interface ILifecycleObserver : LifecycleObserver {
   

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event)

}

注意：当然你也可以不实现LifecycleObserver而是实现 DefaultLifecycleObserver 接口，Google官方更推荐我们使用 DefaultLifecycleObserver 接口

你可以在build.gradle 中依赖，然后就能使用了

def lifecycle_version = "2.2.0"
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

class BaseLifecycle : DefaultLifecycleObserver {
   
		//处理生命周期回调
}

2.2.定义ActivityLifecycleObserver类

定义ActivityLifecycleObserver类去实现我们定义好的ILifecycleObserver接口

class ActivityLifecycleObserver : ILifecycleObserver {
   

    private var mTag = javaClass.simpleName
    override fun onCreate(owner: LifecycleOwner) {
   
        "onCreate ".logWithTag(mTag)
    }

    override fun onStart(owner: LifecycleOwner) {
   
        "onStart ".logWithTag(mTag)
    }

    override fun onResume(owner: LifecycleOwner) {
   
        "onResume ".logWithTag(mTag)
    }

    override fun onPause(owner: LifecycleOwner) {
   
        "onPause ".logWithTag(mTag)
    }

    override fun onStop(owner: LifecycleOwner) {
   
        "onStop ".logWithTag(mTag)
    }

    override fun onDestroy(owner: LifecycleOwner) {
   
        "onDestroy ".logWithTag(mTag)
    }

    override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
   
        "onLifecycleChanged  owner = $owner     event = $event".logWithTag(mTag)
    }

}

这个类中，我们在对应的生命周期方法中，打印一句Log，方便测试！这个类就是我们将要使用的类，它是一个观察者，可以观察Activity/Fragment的生命周期

2.3.定义BaseActivity

在我们的BaseActivity中通过getLifecycle()获取一个Lifecycle，然后把我们的ActivityLifecycleObserver添加进来

open class BaseActivity : AppCompatActivity() {
   
    override fun onCreate(savedInstanceState: Bundle?) {
   
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(ActivityLifecycleObserver())//1
    }
}

Lifecycle是被观察者，通过Add的方式把LifecycleObserver这个观察者添加进来，然后在Activity 执行到对应生命周期的时候通知观察者

**注意：**此时ActivityLifecycleObserver就可以感知Activity的生命周期了，就是这么的神奇

2.4.定义LifecycleActivity类

让LifecycleActivity**继承 **BaseActivity，然后运行代码，看日志

class LifecycleActivity : BaseActivity()

LifecycleActivity来作为我们默认启动的Activity，启动LifecycleActivity然后关闭页面，来查看生命周期的日志！

2.5.结果日志

E/ActivityLifecycleObserver: onCreate
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_CREATE
E/ActivityLifecycleObserver: onStart
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_START
E/ActivityLifecycleObserver: onResume
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_RESUME
E/ActivityLifecycleObserver: onPause
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_PAUSE
E/ActivityLifecycleObserver: onStop
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_STOP
E/ActivityLifecycleObserver: onDestroy
E/ActivityLifecycleObserver: onLifecycleChanged  owner = com.jhb.awesomejetpack.lifecycle.LifecycleActivity@56d55b5     event = ON_DESTROY

每当LifecycleActivity发生了对应的生命周期改变，ActivityLifecycleObserver就会执行对应事件注解的方法，其中onLifecycleChanged的注解是**@OnLifecycleEvent(Lifecycle.Event.ON_ANY)**所以每次都会调用

总结上面的现象：

我们声明了一个ILifecycleObserver接口，并在方法中加入了 @OnLifecycleEvent(Lifecycle.Event.XXX)注解，在BaseActivity的onCreate方法中通过lifecycle.addObserver(ActivityLifecycleObserver())这行代码，然后就可以在 ActivityLifecycleObserver 对应的方法中实现对具体Activity的生命周期回调了，好神奇！为什么会是这样呢？

3.抛出问题

• Lifecycle是怎样感知生命周期的？

• Lifecycle是如何处理生命周期的？

• LifecycleObserver的方法是怎么回调的呢？

• 为什么LifecycleObserver可以感知到Activity的生命周期

下面就一步一步的具体分析，阅读源码，从源码中寻找答案

4.Lifecycle的原理分析的前置准备

在分析 Lifecycle 源码之前，我们必须先对几个重要的类有感性的认识，方便下面看源码！

4.1.LifecycleOwner

public interface LifecycleOwner {
   
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

生命周期持有者，返回一个Lifecycle对象，如果你使用的是 AndroidX（也属于 Jetpack 一部分）在这Activity 、Fragment 两个类中，默认实现了 LifecycleOwner 接口

我贴下代码：

下面都是简化后的代码

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,XXX {
   

	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    public Lifecycle getLifecycle() {
   
        return mLifecycleRegistry;
    }

}

public class Fragment implements LifecycleOwner,XXX {
   

	private final LifecycleRegistry mLifecycleRegistry;

    public Fragment() {
   
        initLifecycle();
    }

    private void initLifecycle() {
   
        mLifecycleRegistry = new LifecycleRegistry(this);
        //....
    }