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

JetPack系列教程（三）：Lifecycle——给Activity和Fragment装个“生命探测仪“

news 2025/8/11 8:36:44

JetPack系列教程（三）：Lifecycle——给Activity和Fragment装个"生命探测仪"

一、Lifecycle：解耦界的"月老"，专治生命周期乱炖

各位安卓开发界的"架构师"们，是否曾为Activity/Fragment的生命周期管理抓狂？明明想在onPause里暂停视频播放，却总在onStop里漏掉资源释放；明明想在onDestroy里取消网络请求，却总被内存泄漏的幽灵纠缠。别慌，JetPack Lifecycle组件就是来拯救你的"月老"，专治各种生命周期乱炖！
在这里插入图片描述

1.1 传统写法：代码像团乱麻

class MainActivity : AppCompatActivity() {private lateinit var videoPlayer: VideoPlayerprivate lateinit var locationManager: LocationManageroverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)videoPlayer = VideoPlayer() // 初始化视频播放器locationManager = LocationManager() // 初始化定位服务}override fun onResume() {super.onResume()videoPlayer.start() // 恢复播放locationManager.start() // 开始定位}override fun onPause() {super.onPause()videoPlayer.pause() // 暂停播放locationManager.stop() // 停止定位}override fun onDestroy() {super.onDestroy()videoPlayer.release() // 释放资源locationManager.release() // 释放定位资源}
}

这段代码像不像你上周写的？Activity和视频播放器、定位服务紧紧耦合，生命周期方法里塞满了各种操作，维护起来简直是一场噩梦^[10]。

1.2 Lifecycle登场：解耦界的"月老"

JetPack Lifecycle组件的核心思想是观察者模式，让自定义组件能自动感知宿主（Activity/Fragment）的生命周期变化。就像给Activity装了个"生命探测仪"，组件们可以自主决定在什么生命周期做什么事。

class VideoPlayerObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)fun startPlaying() {println("视频开始播放")}@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)fun pausePlaying() {println("视频暂停播放")}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)fun releaseResources() {println("释放视频资源")}
}class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)lifecycle.addObserver(VideoPlayerObserver()) // 注册观察者}
}

看！现在Activity的生命周期方法里干干净净，所有操作都交给VideoPlayerObserver处理。代码结构清晰，维护起来轻松愉快^[2][9]。

二、Lifecycle核心组件：三个"小精灵"的魔法

Lifecycle组件家族有三个核心成员：Lifecycle、LifecycleOwner和LifecycleObserver，它们像三个小精灵，共同完成生命周期管理的魔法。

2.1 Lifecycle：生命周期的"记录本"

Lifecycle是个抽象类，记录着组件的生命周期状态和事件：

State：表示当前生命周期状态（INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED）
Event：表示生命周期事件（ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY）

// 获取当前状态
val currentState = lifecycle.currentState// 处理生命周期事件
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)

2.2 LifecycleOwner：生命周期的"主人"

LifecycleOwner是个接口，任何实现了它的类都能提供Lifecycle对象。在Android中，AppCompatActivity和Fragment都已经实现了这个接口：

// Activity获取Lifecycle
val lifecycle = activity.lifecycle// Fragment获取Lifecycle
val lifecycle = fragment.lifecycle

2.3 LifecycleObserver：生命周期的"监听者"

LifecycleObserver是个接口，用于定义监听Lifecycle事件的观察者。通过注解标记方法，可以在相应生命周期事件发生时执行操作：

class MyObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)fun onCreate() {println("宿主创建了")}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)fun onDestroy() {println("宿主销毁了")}
}

三、Lifecycle使用场景：从Activity到Service的全覆盖

3.1 解耦Activity与组件

最常见的场景是解耦Activity和各种服务（视频播放、定位、传感器等）：

class LocationObserver(private val context: Context) : LifecycleObserver {private var locationManager: LocationManager? = null@OnLifecycleEvent(Lifecycle.Event.ON_START)fun startLocation() {locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager// 开始定位...}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)fun stopLocation() {locationManager?.removeUpdates(this)locationManager = null}
}class MapsActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)lifecycle.addObserver(LocationObserver(this))}
}

3.2 解耦Service与组件

LifecycleService让Service也能享受生命周期管理的便利：

class MyService : LifecycleService() {override fun onCreate() {super.onCreate()lifecycle.addObserver(MyServiceObserver())}
}class MyServiceObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)fun init() {println("Service创建了")}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)fun cleanup() {println("Service销毁了")}
}

3.3 全局应用生命周期监听

用ProcessLifecycleOwner监听整个应用的生命周期：

class MyApp : Application() {override fun onCreate() {super.onCreate()ProcessLifecycleOwner.get().lifecycle.addObserver(AppObserver())}
}class AppObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_START)fun onAppForeground() {println("应用进入前台")}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)fun onAppBackground() {println("应用进入后台")}
}

四、Lifecycle进阶用法：从注解到接口的演变

4.1 注解方式（已弃用，但简单易懂）

// 已弃用，但在旧项目中仍可见
class OldObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)fun onResume() {println("ON_RESUME")}
}

⚠️ 注意：从lifecycle-runtime 2.4.0开始，@OnLifecycleEvent注解已被弃用，因为它依赖反射，存在性能和类型安全问题^[9]。

4.2 LifecycleEventObserver（推荐）

class EventObserver : LifecycleEventObserver {override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {when (event) {Lifecycle.Event.ON_RESUME -> println("ON_RESUME")Lifecycle.Event.ON_PAUSE -> println("ON_PAUSE")else -> {}}}
}

4.3 DefaultLifecycleObserver（更优推荐）

class DefaultObserver : DefaultLifecycleObserver {override fun onResume(owner: LifecycleOwner) {println("ON_RESUME")}override fun onPause(owner: LifecycleOwner) {println("ON_PAUSE")}
}

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

五、Lifecycle原理揭秘：观察者模式的魔法

Lifecycle的核心是观察者模式，让我们揭开它的魔法面纱：

注册观察者：lifecycle.addObserver(observer)将观察者添加到LifecycleRegistry中
状态变化通知：当宿主生命周期变化时，LifecycleRegistry通知所有观察者
事件分发：观察者根据事件类型执行相应方法

// LifecycleRegistry核心代码简化版
class LifecycleRegistry : Lifecycle {private val observerMap = HashMap<LifecycleObserver, ObserverWithState>()fun addObserver(observer: LifecycleObserver) {val state = currentStateobserverMap[observer] = ObserverWithState(observer, state)}fun handleLifecycleEvent(event: Lifecycle.Event) {val nextState = getStateAfter(event)moveToState(nextState)}private fun moveToState(nextState: State) {// 遍历所有观察者，通知状态变化observerMap.forEach { (observer, stateObserver) ->if (stateObserver.state.isAtLeast(nextState)) {return}stateObserver.dispatchEvent(this, event)}mState = nextState}
}

六、实战案例：用Lifecycle管理MediaPlayer

让我们用一个完整的案例来巩固知识——用Lifecycle管理MediaPlayer：

class AudioPlayerManager(private val context: Context) : DefaultLifecycleObserver {private var mediaPlayer: MediaPlayer? = nulloverride fun onStart(owner: LifecycleOwner) {mediaPlayer = MediaPlayer.create(context, R.raw.sample_audio)mediaPlayer?.start()}override fun onStop(owner: LifecycleOwner) {mediaPlayer?.stop()mediaPlayer?.release()mediaPlayer = null}
}class AudioActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)lifecycle.addObserver(AudioPlayerManager(this))}
}

这个案例中，AudioPlayerManager实现了DefaultLifecycleObserver接口，在onStart时播放音频，在onStop时停止并释放资源。Activity的生命周期变化会自动通知AudioPlayerManager，完全解耦了音频播放逻辑和Activity代码^[13]。