Android Jetpack 系列（三） Lifecycle 生命周期感知组件详解

原创于 2025-06-09 18:29:58 发布 · 720 阅读

CC 4.0 BY-SA版权

文章标签：

#Lifecycle #LifecycleOwner #Observer #Dispatcher #生命周期

1. 简介

在开发自定义组件时，我们经常需要根据宿主组件（如 Activity 或 Fragment）的生命周期执行特定逻辑。传统做法是提供外部可调用方法，在宿主组件的生命周期回调中手动调用这些方法。这种方式虽然直接，但容易导致代码结构臃肿，逻辑分散，且随着功能复杂度提升，维护成本也会显著增加，出错的概率也更高。

为了解决这一痛点，Android Jetpack 提供了 androidx.lifecycle 软件包，引入了“生命周期感知组件（Lifecycle-aware components）”的概念。借助这些组件，我们可以让自定义组件自主感知宿主的生命周期变化，从而在组件内部完成逻辑管理，摆脱对外部回调的依赖，形成闭环。这样不仅使代码更加清晰、精简，也极大提升了可维护性和可复用性。

2. 传统实现示例

下面是一个传统实现方式的示例，用于展示如何在 Activity 中启动和停止定位服务：

class MyLocationListener(
    private val context: Context,
    private val callback: (Location) -> Unit
) {

    fun startLocationService() {
        // 连接系统定位服务
    }

    fun stopLocationService() {
        // 断开系统定位服务
    }

    fun clear() {
        // 释放资源
    }
}

class MainActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        myLocationListener = MyLocationListener(this) { location ->
            // 更新 UI
        }
    }

    override fun onStart() {
        super.onStart()
        myLocationListener.startLocationService()
    }

    override fun onStop() {
        super.onStop()
        myLocationListener.stopLocationService()
    }

    override fun onDestroy() {
        super.onDestroy()
        myLocationListener.clear()
    }
}

尽管这段代码看起来结构合理，但它暴露了一个常见问题：组件生命周期的管理依赖于外部调用。随着项目中自定义组件数量的增加，Activity 或 Fragment 的生命周期方法中将充斥着类似的调用逻辑，不仅可读性降低，也加大了出错风险，维护难度随之增加。

3. Lifecycle组件

为了让组件能够自动感知生命周期并解耦宿主逻辑，androidx.lifecycle 提供了更优雅的解决方案 —— Lifecycle 组件。

androidx.lifecycle 包提供了一系列支持生命周期感知的类和接口。其核心是 Lifecycle 抽象类，用于表示和存储宿主组件（如 Activity 或 Fragment）的生命周期状态。自定义组件可以通过观察 Lifecycle 的状态变化，自动感知宿主生命周期，从而动态调整自身行为。

目前，Android Studio 新建项目默认已引入该库，如果是旧项目，需要手动添加 androidx.lifecycle 依赖，具体依赖项和版本信息请参考 Android 官网 Lifecycle 版本说明。

3.1. LifecycleObserver（观察者）

Lifecycle 组件的核心是观察者模式。通过注册生命周期观察者，组件可以自动感知宿主的生命周期变化。实现 LifecycleObserver 的方式主要有三种。

3.1.1 继承 LifecycleObserver （已弃用）

最早的生命周期感知写法是实现 LifecycleObserver 接口，并使用 @OnLifecycleEvent 注解：

class MyLocationListener (
    private val context: Context,
    private val callback: (Location) -> Unit
) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun startLocationService() {
        // 连接系统定位服务
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stopLocationService() {
        // 断开系统定位服务
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun clear() {
        // 释放资源
    }
}

⚠️ 注意：从 lifecycle-runtime 2.4.0 开始，@OnLifecycleEvent 已被弃用。因为该方式依赖反射，存在性能和类型安全问题，不再推荐。

3.1.2.继承 LifecycleEventObserver （推荐）

推荐使用 LifecycleEventObserver，它提供统一的生命周期事件分发接口。

class MyLocationListener (
    private val context: Context,
    private val callback: (Location) -> Unit
) : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_START -> startLocationService()
            Lifecycle.Event.ON_STOP -> stopLocationService()
            Lifecycle.Event.ON_DESTROY -> clear()
            else -> {}
        }
    }


    private fun startLocationService() {
        // 连接系统定位服务
    }

    private fun stopLocationService() {
        // 断开系统定位服务
    }

    private fun clear() {
        // 释放资源
    }
}

该接口适合：

需要监听全生命周期事件
动态注册场景

3.1.3.继承DefaultLifecycleObserver （更优推荐）

DefaultLifecycleObserver 是目前官方更推荐的写法，具备更好的语义性，且无需手动处理事件类型。

class MyLocationListener (
    private val context: Context,
    private val callback: (Location) -> Unit
) : DefaultLifecycleObserver {

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        startLocationService()
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        stopLocationService()
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        clear()

    }

    private fun startLocationService() {
        // 连接系统定位服务
    }

    private  fun stopLocationService() {
        // 断开系统定位服务
    }

    private  fun clear() {
        // 释放资源
    }
}

优势：

无需关心事件类型（更安全）
方法语义清晰（更易维护）

3.2. LifecycleOwner（被观察者）

LifecycleOwner 接口用于标识一个类拥有生命周期能力，所有 Activity 和 Fragment 默认都实现了 LifecycleOwner。

以 ComponentActivity 为例：

class ComponentActivity : Activity(), LifecycleOwner, KeyEventDispatcher.Component {

    private val lifecycleRegistry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry
}

开发时，常用的 AppCompatActivity 和 Fragment 已默认实现，无需额外处理。

3.2.1.注册观测者

在宿主组件中，通过 lifecycle.addObserver() 注册观察者：

class MainActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

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

        myLocationListener = MyLocationListener(this) { location ->
            // 更新UI
        }
        lifecycle.addObserver(myLocationListener)
    }
}

这样，自定义组件就可以自动感知宿主的生命周期变化，宿主无需手动调用组件内部方法。

3.3. Lifecycle 的事件和状态

Lifecycle 使用两种核心枚举：

3.1.1. Lifecycle.Event（生命周期事件）

生命周期事件是瞬时的动作：

ON_CREATE → 组件被创建
ON_START → 组件即将可见
ON_RESUME → 组件获得焦点
ON_PAUSE, ON_STOP, ON_DESTROY → 生命周期即将结束或中断

事件更像是“门被打开”的瞬间。

3.1.2. Lifecycle.State（生命周期状态）

生命周期状态是持续性的：

INITIALIZED →对象已构造但还没调用 onCreate
CREATED →调用了 onCreate，但未可见
STARTED →调用了 onStart，用户可见但不可交互
RESUMED →调用了 onResume，用户可交互
DESTROYED →被销毁

状态更像是“门当前是开着的”。

3.1.3. Event 和 State 的关系

下面这图是 Android activity 生命周期的状态和事件：

事件和状态的对应关系：

生命周期事件（Lifecycle.Event）	触发后对应的状态（Lifecycle.State）
ON_CREATE	CREATED
ON_START	STARTED
ON_RESUME	RESUMD
ON_PAUSE	STARTED
ON_STOP	CREATED
ON_DESTROY	DESTROYED

🔍 为什么没有 PAUSED 或 STOPPED 状态？

因为它们并不是持久状态，系统只将 STARTED、CREATED、RESUMED 等视为稳定状态。PAUSED 和 STOPPED 更像是过渡阶段。

3.4. 自定义 LifecycleOwner —— LifecycleRegistry

如果需要让自定义类（如自定义View、任意组件）也具备生命周期能力，使其成为被观察者，可以使用 LifecycleRegistry。示例：

自定义被观察者 LifecycleOwner

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

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry

    fun onCreate() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

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

    fun onResume() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
    }

    fun onPause() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    }

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

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

观察者

class MyLifecycleObserver : DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {
        println("Observer: onCreate, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onStart(owner: LifecycleOwner) {
        println("Observer: onStart, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onResume(owner: LifecycleOwner) {
        println("Observer: onResume, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onPause(owner: LifecycleOwner) {
        println("Observer: onPause, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onStop(owner: LifecycleOwner) {
        println("Observer: onStop, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        println("Observer: onDestroy, 当前状态=${owner.lifecycle.currentState}")
    }
}

注册与模拟生命周期

val myLifecycleObserver = MyLifecycleObserver()
val myLifecycleOwner = MyLifecycleOwner()

myLifecycleOwner.lifecycle.addObserver(myLifecycleObserver)

// 模拟生命周期事件流转
myLifecycleOwner.onCreate()
myLifecycleOwner.onStart()
myLifecycleOwner.onResume()
myLifecycleOwner.onPause()
myLifecycleOwner.onStop()
myLifecycleOwner.onDestroy()

同理，如果你有一个旧较的项目中的Activity希望使其成为生命周期的被观察者。示例：

被观察者MyActivity

class MyActivity : Activity(), LifecycleOwner {
    private lateinit var lifecycleRegistry: LifecycleRegistry

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry

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

        lifecycleRegistry = LifecycleRegistry(this)


        val myLifecycleObserver = MyLifecycleObserver()
        lifecycle.addObserver(myLifecycleObserver)

//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

//    override fun onStart() {
//        super.onStart()
//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
//    }
//
//    override fun onResume() {
//        super.onResume()
//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
//    }
//
//    override fun onPause() {
//        super.onPause()
//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
//    }
//
//    override fun onStop() {
//        super.onStop()
//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
//    }
//
//    override fun onDestroy() {
//        super.onDestroy()
//        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
//    }
}

🔍 即使注释了 handleLifecycleEvent，为什么观察者类中仍然有回调？

如果项目已经引入 androidx.lifecycle:lifecycle-runtime 或 lifecycle-runtime-ktx，Jetpack 会通过 Application.registerActivityLifecycleCallbacks 自动同步生命周期状态。

核心逻辑在 lifecycle-runtime 的内部源码：

lifecycle-runtime/src/androidMain/kotlin/androidx/lifecycle/ReportFragment.android.kt

@JvmStatic
internal fun dispatch(activity: Activity, event: Lifecycle.Event) {
    if (activity is LifecycleRegistryOwner) {
        activity.lifecycle.handleLifecycleEvent(event)
        return
    }
    if (activity is LifecycleOwner) {
        val lifecycle = (activity as LifecycleOwner).lifecycle
        if (lifecycle is LifecycleRegistry) {
            lifecycle.handleLifecycleEvent(event)
        }
    }
}

简单来说：

Jetpack 监听所有 Activity 生命周期
如果 Activity 实现了 LifecycleOwner，并返回 LifecycleRegistry
系统会自动同步状态，无需手动调用
这就是为什么在 AndroidX 项目中，很多情况下我们可以直接使用 lifecycle.addObserver 而无需额外处理。

4. 在 Service 中使用Lifecycle

在 Android 的原生设计中，Service 并未实现 LifecycleOwner 接口，无法直接被 Jetpack Lifecycle 框架感知或观察。如果你希望在 Service 中使用 lifecycle.addObserver()，就必须“伪造”一个 LifecycleOwner。

Jetpack 官方提供了 ServiceLifecycleDispatcher，用于为 Service 提供生命周期感知能力。

4.1. ServiceLifecycleDispatcher

ServiceLifecycleDispatcher 是 Jetpack 在 androidx.lifecycle:lifecycle-service 库中提供的类，可以帮助 Service 组件拥有 Lifecycle 能力。通过它，Service 可以成为 LifecycleOwner，进而支持 LifecycleObserver 或 DefaultLifecycleObserver。示例：

被观察者 MyService

class MyService : Service(), LifecycleOwner {
    private var dispatcher = ServiceLifecycleDispatcher(this)

    override val lifecycle: Lifecycle
        get() = dispatcher.lifecycle

    private val myLifecycleObserver = MyLifecycleObserver()

    override fun onCreate() {
        dispatcher.onServicePreSuperOnCreate()
        super.onCreate()

        lifecycle.addObserver(myLifecycleObserver)
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        dispatcher.onServicePreSuperOnStart()
        return super.onStartCommand(intent, flags, startId)
    }

    override fun onDestroy() {
        dispatcher.onServicePreSuperOnDestroy()
        super.onDestroy()
    }

    override fun onBind(intent: Intent): IBinder? {
        dispatcher.onServicePreSuperOnBind()
        return null
    }
}

观察者 MyLifecycleObserver

class MyLifecycleObserver : DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {
        println("Observer: onCreate, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onStart(owner: LifecycleOwner) {
        println("Observer: onStart, 当前状态=${owner.lifecycle.currentState}")
    }

//    override fun onResume(owner: LifecycleOwner) {
//        println("Observer: onResume, 当前状态=${owner.lifecycle.currentState}")
//    }
//
//    override fun onPause(owner: LifecycleOwner) {
//        println("Observer: onPause, 当前状态=${owner.lifecycle.currentState}")
//    }

    override fun onStop(owner: LifecycleOwner) {
        println("Observer: onStop, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        println("Observer: onDestroy, 当前状态=${owner.lifecycle.currentState}")
    }
}

说明：

ServiceLifecycleDispatcher 内部维护了一个 LifecycleRegistry，通过调用 onServicePreSuperOnXXX() 方法，实际是驱动 LifecycleRegistry 的状态变化，并通知所有注册的观察者。
dispatcher.onServicePreSuperOnXXX 方法必须在 super.XXX() 方法之前调用，这是 Jetpack 官方推荐的调用顺序，确保生命周期事件及时分发，避免生命周期状态滞后，导致观察者感知不准确。
在 Service 中没有 onResume 和 onPause，因此观察者不需要实现这两个回调。

4.2. 对应生命周期映射关系

Service 方法	Dispatcher 方法	分发的 Lifecycle 事件顺序	Lifecycle 状态变化
onCreate()	onServicePreSuperOnCreate()	ON_CREATE	INITIALIZED → CREATED
onStartCommand()	onServicePreSuperOnStart()	ON_START	CREATED → STARTED
onBind()	onServicePreSuperOnBind()	ON_START	CREATED → STARTED
onDestroy()	onServicePreSuperOnDestroy()	ON_STOP→ON_DESTROY	STARTED → DESTROYED

4.3. LifecycleService（官方封装）

如果不想手动管理 ServiceLifecycleDispatcher，Jetpack 已封装了 LifecycleService，你只需继承它即可自动获得 LifecycleOwner 能力。示例：

修改被观察者 MyService

class MyService : LifecycleService() {
    private val myLifecycleObserver = MyLifecycleObserver()

    override fun onCreate() {
        super.onCreate()

        lifecycle.addObserver(myLifecycleObserver)
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        return super.onStartCommand(intent, flags, startId)
    }

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

    override fun onBind(intent: Intent): IBinder? {
        super.onBind(intent)
        return null
    }
}

说明：

LifecycleService 已自动处理 Dispatcher 的生命周期管理，开发者只需专注于注册观察者即可。

5. 在 Application 中使用 Liefcycle

5.1. 传统方案：Activity 计数法

过去，监听应用是否处于前台，通常通过 registerActivityLifecycleCallbacks 来实现。示例：

var activityCount = 0
fun registerActivityLifecycleCallbacks(application: Application) {
    application.registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
        override fun onActivityStarted(activity: Activity) {
        }

        override fun onActivityResumed(activity: Activity) {
            activityCount++
        }
        override fun onActivityPaused(activity: Activity) {
            activityCount--
        }
        override fun onActivityStopped(activity: Activity) { }

        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
        override fun onActivityDestroyed(activity: Activity) { }
    })
}

通过判断 activityCount > 0，可以推断应用是否处于前台。

5.2. 推荐方案：ProcessLifecycleOwner

Jetpack 在androidx.lifecycle:lifecycle-process 库提供了更简洁的全局生命周期感知类 ProcessLifecycleOwner，用于监听整个应用的生命周期状态。示例：

被观察者 MyApplication

class MyApplication : Application() {
    private val myLifecycleObserver = MyLifecycleObserver()

    override fun onCreate() {
        super.onCreate()

        ProcessLifecycleOwner.get().lifecycle.addObserver(myLifecycleObserver)
    }
}

观察者 MyLifecycleObserver

class MyLifecycleObserver : DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {
        println("Observer: onCreate, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onStart(owner: LifecycleOwner) {
        println("Observer: onStart, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onResume(owner: LifecycleOwner) {
        println("Observer: onResume, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onPause(owner: LifecycleOwner) {
        println("Observer: onPause, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onStop(owner: LifecycleOwner) {
        println("Observer: onStop, 当前状态=${owner.lifecycle.currentState}")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        println("Observer: onDestroy, 当前状态=${owner.lifecycle.currentState}")
    }
}

说明：

ProcessLifecycleOwner 监听的是整个应用进程的生命周期，与 Activity 或 Service 数量无关。
onCreate 仅在应用启动时调用一次，onDestroy 不会被调用，因为应用被杀死时不会触发常规生命周期。
当应用从前台退到后台时，会依次调用 onPause → onStop；从后台回到前台时，会依次调用 onStart → onResume。
onPause 和 onStop 的调用存在一定延迟，系统会等待确认是否为屏幕旋转或短暂切换场景，避免误判。

6. 总结

Jetpack Lifecycle 框架为 Android 提供了更优雅、更统一的生命周期管理能力。虽然 Activity 和 Fragment 天生支持 Lifecycle，但 Service 和 Application 这类组件原生并不具备 Lifecycle 感知能力。针对这种情况，Jetpack 提供了相应的扩展工具：

在 Service 中，可以通过 ServiceLifecycleDispatcher 手动接入 Lifecycle，或者直接继承官方封装好的 LifecycleService，简化开发流程。
在 Application 中，可以使用 ProcessLifecycleOwner 全局感知应用的前后台状态，相比传统的 Activity 计数法更加准确和便捷。

合理地使用 Lifecycle，不仅有助于简化生命周期事件的监听，还能避免内存泄漏、回调失效等问题，提升应用的架构健壮性和代码可维护性。了解并掌握这些进阶用法，有助于开发者在复杂场景中写出更优雅的 Android 应用。

更多详细的 Lifecycle 介绍，请访问 Android 开发者官网。