第2章 Lifecycle

课程目录第2章 Lifecycle

2、Lifecycle：Lifecycle原理、LifecycleObserver、LifecycleOwner、自定义LifecycleOwner、实战：感知生命周期

各位同学，今天我们来聊聊 Jetpack 里最基础、也最核心的一个组件——Lifecycle。

说实话，我刚开始接触 Android 开发那会儿，最头疼的就是生命周期管理。Activity 和 Fragment 的生命周期回调散落在各处，稍不留神就会在 onDestroy 之后还去更新 UI，直接崩给你看。后来 Google 推出了 Lifecycle 组件，我才算真正解脱了。

说白了，Lifecycle 就是一套标准化的生命周期感知方案。它让我们的组件能够主动「知道」当前处于哪个生命周期阶段，从而做出正确的行为。

Lifecycle 的核心原理

Lifecycle 本身是一个抽象类，它维护了一个状态机。这个状态机有两个关键概念：Event 和 State。

概念	说明
Event	生命周期事件，比如 ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY
State	当前生命周期状态，比如 CREATED、STARTED、RESUMED、DESTROYED

Event 推动 State 的变化。举个例子：当 Activity 走到 onCreate，Lifecycle 会分发 ON_CREATE 事件，状态就从 INITIALIZED 变为 CREATED。当 onStart 被调用，ON_START 事件发出，状态变为 STARTED。嗯，这里要注意：状态是向上走的，不会跳级。

核心要点：Lifecycle 使用观察者模式。LifecycleOwner 是被观察者，LifecycleObserver 是观察者。当生命周期变化时，LifecycleOwner 通知所有注册的 Observer。

我画了一张图，帮你理解这个流程：

LifecycleObserver：如何监听生命周期

LifecycleObserver 是一个空接口，我们通过注解或者 DefaultLifecycleObserver 来实现监听。

我个人习惯用 DefaultLifecycleObserver，因为它是 Java 8 接口，方法名清晰，不需要反射。你想想看，用注解的方式虽然也行，但反射毕竟有性能损耗，而且容易写错方法名。

class MyObserver : 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) {
        // 清理操作
    }
}

小技巧：如果你只需要监听个别事件，用注解方式更简洁。比如只关心 onDestroy：

class MyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun cleanUp() {
        // 清理资源
    }
}

LifecycleOwner：谁提供生命周期

LifecycleOwner 是一个接口，只有一个方法：getLifecycle()。AppCompatActivity 和 Fragment 默认实现了这个接口。所以你在 Activity 里可以直接调用 lifecycle.addObserver(observer)。

我记得有一次，我在一个自定义 View 里需要感知 Activity 的生命周期。当时我直接传入了 Activity 实例，但这样耦合太强了。后来我改成传入 LifecycleOwner，代码立马清爽了很多。

class MyCustomView(context: Context, attrs: AttributeSet?) : View(context, attrs) {

    fun bindLifecycle(owner: LifecycleOwner) {
        owner.lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onDestroy(owner: LifecycleOwner) {
                // 释放资源
            }
        })
    }
}

自定义 LifecycleOwner

有时候我们需要自己实现 LifecycleOwner。比如你写了一个自定义的 Service，或者一个后台任务管理器，想让外部组件感知它的生命周期。

怎么做呢？核心就是使用 LifecycleRegistry。它是 Lifecycle 的具体实现类，负责管理状态和分发事件。

class MyLifecycleOwner : LifecycleOwner {
    private val lifecycleRegistry = LifecycleRegistry(this)

    override fun getLifecycle(): Lifecycle = lifecycleRegistry

    fun start() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    fun stop() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

    fun destroy() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    }
}

注意：LifecycleRegistry 不是线程安全的。如果你在多线程环境下调用 handleLifecycleEvent，需要自己加锁。我曾经在项目里踩过这个坑，多个线程同时触发事件，导致状态错乱。后来我加了一个 synchronized 块才解决。

实战：感知生命周期

光说不练假把式。我们来看一个实际场景：定位管理器。在 Activity 可见时开始定位，不可见时停止定位，避免电量浪费。

class LocationManager(private val lifecycleOwner: LifecycleOwner) {

    init {
        lifecycleOwner.lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onStart(owner: LifecycleOwner) {
                startLocationUpdates()
            }

            override fun onStop(owner: LifecycleOwner) {
                stopLocationUpdates()
            }
        })
    }

    private fun startLocationUpdates() {
        // 开始定位
    }

    private fun stopLocationUpdates() {
        // 停止定位
    }
}

在 Activity 中使用：

class MainActivity : AppCompatActivity() {
    private lateinit var locationManager: LocationManager

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

        locationManager = LocationManager(this)
    }
}

你看，这样写的好处是：LocationManager 完全不需要知道 Activity 的存在。它只依赖 LifecycleOwner，生命周期逻辑完全由 Lifecycle 组件托管。这就是解耦的魅力。

总结一下：Lifecycle 组件让生命周期管理变得可预测、可测试、可复用。它把「什么时候该做什么事」这个逻辑从 Activity/Fragment 中抽离出来，放到了专门的 Observer 里。你想想看，如果你的项目里到处都是生命周期相关的 if-else，那代码该有多乱？

好了，这一章的内容就到这里。Lifecycle 虽然基础，但它是 LiveData、ViewModel、Room 等组件的基石。把这一章吃透，后面的学习会轻松很多。

公众号:蓝海资料掘金营，微信deep3321