Jacky's blog
Jacky
2025-07-08
目录

Jetpack Lifecycle详解

# 基础知识

Jetpack Lifecycle是Android架构组件的一部分，用于管理Android组件（如Activity、Fragment）的生命周期。它提供了一种响应式的方式来处理生命周期事件，避免内存泄漏和崩溃。

# 核心概念

Lifecycle组件包含以下核心概念：

  • LifecycleOwner: 具有生命周期的组件（如Activity、Fragment）
  • LifecycleObserver: 观察生命周期事件的组件
  • Lifecycle: 定义生命周期状态和事件的接口
  • LifecycleRegistry: Lifecycle的具体实现

# 生命周期状态

enum class State {
    DESTROYED,    // 已销毁
    INITIALIZED,  // 已初始化
    CREATED,      // 已创建
    STARTED,      // 已启动
    RESUMED       // 已恢复
}
1
2
3
4
5
6
7

# 生命周期事件

enum class Event {
    ON_CREATE,    // 创建事件
    ON_START,     // 启动事件
    ON_RESUME,    // 恢复事件
    ON_PAUSE,     // 暂停事件
    ON_STOP,      // 停止事件
    ON_DESTROY    // 销毁事件
}
1
2
3
4
5
6
7
8

# 基本使用

# 1. 添加依赖

dependencies {
    def lifecycle_version = "2.6.2"
    
    // Lifecycle核心库
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
    
    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    
    // 生命周期感知组件
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 2. 创建LifecycleObserver

class MyLifecycleObserver : LifecycleObserver {
    
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        Log.d("Lifecycle", "onCreate called")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        Log.d("Lifecycle", "onStart called")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Log.d("Lifecycle", "onResume called")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        Log.d("Lifecycle", "onPause called")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        Log.d("Lifecycle", "onStop called")
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        Log.d("Lifecycle", "onDestroy called")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 3. 在Activity中使用

class MainActivity : AppCompatActivity() {
    
    private lateinit var lifecycleObserver: MyLifecycleObserver
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // 创建观察者
        lifecycleObserver = MyLifecycleObserver()
        
        // 添加生命周期观察者
        lifecycle.addObserver(lifecycleObserver)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 高级用法

# 1. 使用DefaultLifecycleObserver（推荐）

class MyLifecycleObserver : DefaultLifecycleObserver {
    
    override fun onCreate(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onCreate called")
    }
    
    override fun onStart(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onStart called")
    }
    
    override fun onResume(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onResume called")
    }
    
    override fun onPause(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onPause called")
    }
    
    override fun onStop(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onStop called")
    }
    
    override fun onDestroy(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onDestroy called")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 2. 条件性生命周期观察

class ConditionalLifecycleObserver : DefaultLifecycleObserver {
    
    override fun onStart(owner: LifecycleOwner) {
        // 只在特定条件下执行
        if (owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            Log.d("Lifecycle", "Activity is started")
        }
    }
    
    override fun onResume(owner: LifecycleOwner) {
        // 检查当前状态
        when (owner.lifecycle.currentState) {
            Lifecycle.State.RESUMED -> {
                Log.d("Lifecycle", "Activity is resumed")
            }
            Lifecycle.State.STARTED -> {
                Log.d("Lifecycle", "Activity is started but not resumed")
            }
            else -> {
                Log.d("Lifecycle", "Activity is in other state")
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 3. 自定义LifecycleOwner

class CustomLifecycleOwner : LifecycleOwner {
    
    private val lifecycleRegistry = LifecycleRegistry(this)
    
    init {
        lifecycleRegistry.currentState = Lifecycle.State.INITIALIZED
    }
    
    override fun getLifecycle(): Lifecycle = lifecycleRegistry
    
    fun start() {
        lifecycleRegistry.currentState = Lifecycle.State.STARTED
    }
    
    fun resume() {
        lifecycleRegistry.currentState = Lifecycle.State.RESUMED
    }
    
    fun pause() {
        lifecycleRegistry.currentState = Lifecycle.State.STARTED
    }
    
    fun stop() {
        lifecycleRegistry.currentState = Lifecycle.State.CREATED
    }
    
    fun destroy() {
        lifecycleRegistry.currentState = Lifecycle.State.DESTROYED
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 与ViewModel集成

# 1. 基本ViewModel使用

class MainViewModel : ViewModel() {
    
    private val _data = MutableLiveData<String>()
    val data: LiveData<String> = _data
    
    init {
        _data.value = "Initial data"
    }
    
    fun updateData(newData: String) {
        _data.value = newData
    }
    
    override fun onCleared() {
        super.onCleared()
        Log.d("ViewModel", "ViewModel is cleared")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 2. 在Activity中使用ViewModel

class MainActivity : AppCompatActivity() {
    
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // 观察LiveData
        viewModel.data.observe(this) { data ->
            Log.d("MainActivity", "Data updated: $data")
            updateUI(data)
        }
    }
    
    private fun updateUI(data: String) {
        // 更新UI
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 3. 共享ViewModel

class SharedViewModel : ViewModel() {
    
    private val _selectedItem = MutableLiveData<String>()
    val selectedItem: LiveData<String> = _selectedItem
    
    fun selectItem(item: String) {
        _selectedItem.value = item
    }
}

// 在Fragment中使用
class FragmentA : Fragment() {
    
    private val sharedViewModel: SharedViewModel by activityViewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        sharedViewModel.selectedItem.observe(viewLifecycleOwner) { item ->
            Log.d("FragmentA", "Selected item: $item")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 与LiveData集成

# 1. 基本LiveData使用

class UserRepository {
    
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user
    
    fun loadUser(userId: String) {
        // 模拟网络请求
        viewModelScope.launch {
            delay(1000)
            _user.value = User(userId, "John Doe")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 2. 自定义LiveData

class LocationLiveData : LiveData<Location>() {
    
    private val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    
    private val locationListener = object : LocationListener {
        override fun onLocationChanged(location: Location) {
            value = location
        }
        
        override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
        override fun onProviderEnabled(provider: String?) {}
        override fun onProviderDisabled(provider: String?) {}
    }
    
    override fun onActive() {
        super.onActive()
        // 开始监听位置变化
        locationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER,
            0L,
            0f,
            locationListener
        )
    }
    
    override fun onInactive() {
        super.onInactive()
        // 停止监听位置变化
        locationManager.removeUpdates(locationListener)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 3. LiveData转换

class UserViewModel : ViewModel() {
    
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user
    
    // 转换LiveData
    val userName: LiveData<String> = Transformations.map(_user) { user ->
        user.name
    }
    
    // 切换LiveData源
    val userPosts: LiveData<List<Post>> = Transformations.switchMap(_user) { user ->
        getPostsForUser(user.id)
    }
    
    private fun getPostsForUser(userId: String): LiveData<List<Post>> {
        // 返回用户帖子列表
        return MutableLiveData()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 生命周期感知组件

# 1. 自定义生命周期感知组件

class LifecycleAwareComponent(private val lifecycleOwner: LifecycleOwner) {
    
    private val lifecycleObserver = object : DefaultLifecycleObserver {
        override fun onStart(owner: LifecycleOwner) {
            startComponent()
        }
        
        override fun onStop(owner: LifecycleOwner) {
            stopComponent()
        }
        
        override fun onDestroy(owner: LifecycleOwner) {
            cleanup()
        }
    }
    
    init {
        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
    }
    
    private fun startComponent() {
        Log.d("Component", "Component started")
    }
    
    private fun stopComponent() {
        Log.d("Component", "Component stopped")
    }
    
    private fun cleanup() {
        Log.d("Component", "Component cleaned up")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 2. 网络请求管理

class NetworkManager(private val lifecycleOwner: LifecycleOwner) {
    
    private var currentRequest: Job? = null
    
    private val lifecycleObserver = object : DefaultLifecycleObserver {
        override fun onStop(owner: LifecycleOwner) {
            cancelCurrentRequest()
        }
        
        override fun onDestroy(owner: LifecycleOwner) {
            cancelCurrentRequest()
        }
    }
    
    init {
        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
    }
    
    fun makeRequest(url: String, callback: (String) -> Unit) {
        currentRequest = CoroutineScope(Dispatchers.IO).launch {
            try {
                val response = URL(url).readText()
                withContext(Dispatchers.Main) {
                    callback(response)
                }
            } catch (e: Exception) {
                Log.e("NetworkManager", "Request failed", e)
            }
        }
    }
    
    private fun cancelCurrentRequest() {
        currentRequest?.cancel()
        currentRequest = null
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 3. 定时器管理

class TimerManager(private val lifecycleOwner: LifecycleOwner) {
    
    private var timer: Timer? = null
    private var timerTask: TimerTask? = null
    
    private val lifecycleObserver = object : DefaultLifecycleObserver {
        override fun onStart(owner: LifecycleOwner) {
            startTimer()
        }
        
        override fun onStop(owner: LifecycleOwner) {
            stopTimer()
        }
        
        override fun onDestroy(owner: LifecycleOwner) {
            stopTimer()
        }
    }
    
    init {
        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
    }
    
    private fun startTimer() {
        timer = Timer()
        timerTask = object : TimerTask() {
            override fun run() {
                Log.d("Timer", "Timer tick")
            }
        }
        timer?.scheduleAtFixedRate(timerTask, 0, 1000)
    }
    
    private fun stopTimer() {
        timerTask?.cancel()
        timer?.cancel()
        timer = null
        timerTask = null
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 最佳实践

# 1. 内存泄漏防护

class SafeLifecycleObserver : DefaultLifecycleObserver {
    
    private var weakReference: WeakReference<Context>? = null
    
    fun setContext(context: Context) {
        weakReference = WeakReference(context)
    }
    
    override fun onResume(owner: LifecycleOwner) {
        val context = weakReference?.get()
        if (context != null) {
            // 使用context
            Log.d("SafeObserver", "Context is available")
        } else {
            Log.d("SafeObserver", "Context is null")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 2. 状态管理

class StateManager(private val lifecycleOwner: LifecycleOwner) {
    
    private var currentState: String = "INITIAL"
    
    private val lifecycleObserver = object : DefaultLifecycleObserver {
        override fun onStart(owner: LifecycleOwner) {
            if (currentState == "INITIAL") {
                currentState = "STARTED"
                Log.d("StateManager", "State changed to: $currentState")
            }
        }
        
        override fun onResume(owner: LifecycleOwner) {
            if (currentState == "STARTED") {
                currentState = "RESUMED"
                Log.d("StateManager", "State changed to: $currentState")
            }
        }
        
        override fun onPause(owner: LifecycleOwner) {
            if (currentState == "RESUMED") {
                currentState = "PAUSED"
                Log.d("StateManager", "State changed to: $currentState")
            }
        }
        
        override fun onStop(owner: LifecycleOwner) {
            if (currentState == "PAUSED") {
                currentState = "STOPPED"
                Log.d("StateManager", "State changed to: $currentState")
            }
        }
        
        override fun onDestroy(owner: LifecycleOwner) {
            currentState = "DESTROYED"
            Log.d("StateManager", "State changed to: $currentState")
        }
    }
    
    init {
        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 3. 错误处理

class ErrorHandlingLifecycleObserver : DefaultLifecycleObserver {
    
    override fun onStart(owner: LifecycleOwner) {
        try {
            performStartupTasks()
        } catch (e: Exception) {
            Log.e("ErrorHandling", "Error during startup", e)
            handleError(e)
        }
    }
    
    private fun performStartupTasks() {
        // 执行启动任务
        throw RuntimeException("Simulated error")
    }
    
    private fun handleError(error: Exception) {
        // 处理错误
        Log.e("ErrorHandling", "Handling error: ${error.message}")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 调试和测试

# 1. 生命周期调试

class LifecycleDebugger : DefaultLifecycleObserver {
    
    private val tag = "LifecycleDebugger"
    
    override fun onCreate(owner: LifecycleOwner) {
        Log.d(tag, "onCreate: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    override fun onStart(owner: LifecycleOwner) {
        Log.d(tag, "onStart: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    override fun onResume(owner: LifecycleOwner) {
        Log.d(tag, "onResume: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    override fun onPause(owner: LifecycleOwner) {
        Log.d(tag, "onPause: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    override fun onStop(owner: LifecycleOwner) {
        Log.d(tag, "onStop: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    override fun onDestroy(owner: LifecycleOwner) {
        Log.d(tag, "onDestroy: ${owner.javaClass.simpleName}")
        logCurrentState(owner)
    }
    
    private fun logCurrentState(owner: LifecycleOwner) {
        Log.d(tag, "Current state: ${owner.lifecycle.currentState}")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 2. 单元测试

class LifecycleTest {
    
    @Test
    fun testLifecycleStates() {
        val lifecycleOwner = TestLifecycleOwner()
        val observer = TestLifecycleObserver()
        
        lifecycleOwner.lifecycle.addObserver(observer)
        
        // 测试状态转换
        lifecycleOwner.performRestore(null)
        assertEquals(Lifecycle.State.INITIALIZED, lifecycleOwner.lifecycle.currentState)
        
        lifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
        assertEquals(Lifecycle.State.CREATED, lifecycleOwner.lifecycle.currentState)
        
        lifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START)
        assertEquals(Lifecycle.State.STARTED, lifecycleOwner.lifecycle.currentState)
        
        lifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
        assertEquals(Lifecycle.State.RESUMED, lifecycleOwner.lifecycle.currentState)
    }
}

class TestLifecycleObserver : DefaultLifecycleObserver {
    val events = mutableListOf<Lifecycle.Event>()
    
    override fun onCreate(owner: LifecycleOwner) {
        events.add(Lifecycle.Event.ON_CREATE)
    }
    
    override fun onStart(owner: LifecycleOwner) {
        events.add(Lifecycle.Event.ON_START)
    }
    
    override fun onResume(owner: LifecycleOwner) {
        events.add(Lifecycle.Event.ON_RESUME)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 常见陷阱和解决方案

# 1. 内存泄漏

// 问题：持有Activity引用
class BadObserver(private val activity: MainActivity) : DefaultLifecycleObserver {
    // 这会导致内存泄漏
}

// 解决方案：使用WeakReference
class GoodObserver(activity: MainActivity) : DefaultLifecycleObserver {
    private val activityRef = WeakReference(activity)
    
    override fun onResume(owner: LifecycleOwner) {
        val activity = activityRef.get()
        if (activity != null) {
            // 使用activity
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 2. 重复观察者

// 问题：重复添加观察者
class BadActivity : AppCompatActivity() {
    private val observer = MyLifecycleObserver()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(observer) // 可能重复添加
    }
    
    override fun onResume() {
        super.onResume()
        lifecycle.addObserver(observer) // 重复添加！
    }
}

// 解决方案：检查是否已添加
class GoodActivity : AppCompatActivity() {
    private val observer = MyLifecycleObserver()
    private var observerAdded = false
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (!observerAdded) {
            lifecycle.addObserver(observer)
            observerAdded = true
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 3. 状态检查

// 问题：不检查生命周期状态
class BadComponent {
    fun performAction() {
        // 直接执行，不检查状态
        doSomething()
    }
}

// 解决方案：检查生命周期状态
class GoodComponent(private val lifecycleOwner: LifecycleOwner) {
    fun performAction() {
        if (lifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            doSomething()
        } else {
            Log.w("GoodComponent", "Cannot perform action in current state")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 扩展资源

# 1. 相关库

  • ViewModel: 管理UI相关数据
  • LiveData: 可观察的数据持有者
  • DataBinding: 数据绑定库
  • Room: 数据库抽象层
  • Navigation: 导航组件
  • WorkManager: 后台任务管理

# 2. 学习资源

# 3. 社区资源

  • Stack Overflow: Lifecycle相关问题
  • GitHub: 开源项目和示例
  • Reddit: r/androiddev
  • Discord: Android开发者社区
#Jetpack#lifecycle#Android
上次更新: 2025/10/09, 21:06:25
Room
view_model

← view_model→

最近更新
01
npx 使用指南
10-12
02
cursor
09-28
03
inspect
07-20
更多文章>
Theme by Vdoing | Copyright © 2019-2025 Jacky | MIT License