当前位置： 首页 > ops >正文

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

ops 2025/6/22 22:10:16

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: MyLocationListeneroverride 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() {// 释放资源}
}

该接口适合：

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

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() {// 释放资源}
}

优势：

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

3.2. LifecycleOwner（被观察者）

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

以 ComponentActivity 为例：

class ComponentActivity : Activity(), LifecycleOwner, KeyEventDispatcher.Component {private val lifecycleRegistry = LifecycleRegistry(this)override val lifecycle: Lifecycleget() = lifecycleRegistry
}

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

3.2.1.注册观测者

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

class MainActivity : AppCompatActivity() {private lateinit var myLocationListener: MyLocationListeneroverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)myLocationListener = MyLocationListener(this) { location ->// 更新UI}lifecycle.addObserver(myLocationListener)}
}

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

3.3. Lifecycle 的事件和状态

Lifecycle 使用两种核心枚举：

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

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

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

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

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

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

  1. INITIALIZED →对象已构造但还没调用 onCreate
  2. CREATED →调用了 onCreate，但未可见
  3. STARTED →调用了 onStart，用户可见但不可交互
  4. RESUMED →调用了 onResume，用户可交互
  5. 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: Lifecycleget() = lifecycleRegistryfun 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: LifecycleRegistryoverride val lifecycle: Lifecycleget() = lifecycleRegistryoverride 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).lifecycleif (lifecycle is LifecycleRegistry) {lifecycle.handleLifecycleEvent(event)}}
}

简单来说：

  1. Jetpack 监听所有 Activity 生命周期
  2. 如果 Activity 实现了 LifecycleOwner，并返回 LifecycleRegistry
  3. 系统会自动同步状态，无需手动调用
  4. 这就是为什么在 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: Lifecycleget() = dispatcher.lifecycleprivate 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}")}
}

说明：

  1. ServiceLifecycleDispatcher 内部维护了一个 LifecycleRegistry，通过调用 onServicePreSuperOnXXX() 方法，实际是驱动 LifecycleRegistry 的状态变化，并通知所有注册的观察者。
  2. dispatcher.onServicePreSuperOnXXX 方法必须在 super.XXX() 方法之前调用，这是 Jetpack 官方推荐的调用顺序，确保生命周期事件及时分发，避免生命周期状态滞后，导致观察者感知不准确。
  3. 在 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}")}
}

说明：

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

6. 总结

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

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

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

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

http://www.xdnf.cn/news/13102.html

相关文章：

  • cacert.pem根证书文件
  • PydanticAI 作为 MCP 客户端示例
  • RK3568/RK3588 KVM系统虚拟化解决方案
  • WPS2024 软件下载及安装教程！
  • 关于纯java代码项目，打包jar实现方式
  • Python 训练营打卡 Day 47
  • 免布线+双向通信——电力载波技术重塑楼宇自控能效管理
  • 自建CA并生成自签名SSL证书
  • Cell的复用及自定义Cell
  • STM32嵌套向量中断控制器(NVIC)及外部中断使用案例分析
  • GAMES202-高质量实时渲染（Assignment 4）
  • 【Python基础】异常捕获知识梳理
  • Device Mapper 机制
  • Redis数据结构选择策略--String？Hash？怎么选？
  • C++ Saucer 编写Windows桌面应用
  • AI——DeepSeek+LangChain+streamlit 实现智能汽车维修服务
  • 视觉slam十四讲实践部分记录——ch2、ch3
  • 字节开源代码模型——Seed-Coder 本地部署教程，模型自驱动数据筛选，让每行代码都精准落位！
  • ​第八章：漏洞里的人间烟火
  • Linux线程与进程关系及底层实现
  • 瑞数信息入选Gartner《中国API管理市场指南》
  • 亚马逊测评，采购环境安全需要解决哪些问题，提高成功率
  • 验证redis数据结构
  • 课堂笔记：吴恩达的AI课（AI FOR EVERYONE）-第一周part2 人工智能术语人工智能公司应该怎么做
  • 恶补电源：1.电桥
  • 【第一章:人工智能基础】01.Python基础及常用工具包-(3)常用数据科学工具包
  • 性能测试分析
  • 深度剖析Diffusion与Transformer在图像生成中的计算逻辑与融合之道
  • 火山引擎云服务器使用感怎么样
  • HarmonyOS运动开发：打造你的专属运动节拍器