欢迎来到尧图网

客户服务 关于我们

您的位置：首页 > 教育 > 锐评 > Android Compose 框架组合生命周期（DisposableEffect、LaunchedEffect）深入剖析(十七)

Android Compose 框架组合生命周期（DisposableEffect、LaunchedEffect）深入剖析(十七)

2025/3/28 21:46:13 来源：https://blog.csdn.net/qq_28540861/article/details/146460835  浏览:  次   关键词：Android Compose 框架组合生命周期（DisposableEffect、LaunchedEffect）深入剖析(十七)

Android Compose 框架组合生命周期（DisposableEffect、LaunchedEffect）深入剖析

一、引言

在现代 Android 开发领域，Android Compose 以其声明式的 UI 构建方式逐渐成为开发者的首选。它摒弃了传统 Android 开发中繁琐的视图操作，使得代码更加简洁、易读和可维护。而在 Android Compose 的生态系统中，组合生命周期管理是一个核心且关键的概念。其中，DisposableEffect 和 LaunchedEffect 这两个重要的 API 扮演着举足轻重的角色，它们分别负责资源管理和异步操作的处理，对于保证应用的性能、稳定性以及资源的合理利用起着至关重要的作用。本文将从源码级别出发，对 DisposableEffect 和 LaunchedEffect 进行全面且深入的分析，详细探讨它们的工作原理、使用方法以及在实际开发中的各种应用场景。

二、Android Compose 组合生命周期基础概念

2.1 组合生命周期的基本定义

在 Android Compose 里，组合生命周期描述了 Composable 函数从创建到销毁的整个过程。这个过程包含了多个关键阶段，如组合（composition）、布局（layout）和绘制（drawing）等。每个阶段都有其特定的任务和意义，并且在不同的阶段，Composable 函数可能需要执行不同的操作，例如初始化资源、启动异步任务或者释放资源等。理解组合生命周期的各个阶段，是正确使用 DisposableEffect 和 LaunchedEffect 的基础。

2.2 组合生命周期的重要性

合理管理组合生命周期对于 Android Compose 应用的性能和稳定性有着决定性的影响。如果不能正确处理资源的初始化和释放，就可能会导致内存泄漏、资源浪费等严重问题。例如，在一个 Composable 函数中，如果在组合创建时打开了一个文件或者注册了一个广播接收器，但在组合销毁时没有及时关闭文件或者取消注册广播接收器，就会造成资源的浪费和内存泄漏。而 DisposableEffect 和 LaunchedEffect 正是为了解决这些问题而设计的，它们可以帮助开发者精确控制资源的生命周期，确保资源在需要时被创建，在不需要时被及时释放，从而提高应用的性能和稳定性。

三、DisposableEffect 的使用与源码深度解析

3.1 DisposableEffect 的基础使用示例

DisposableEffect 是一个非常实用的 Composable 函数，主要用于在组合生命周期的特定阶段执行副作用操作，并且在组合被销毁时进行资源清理。下面是一个简单的示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable@Composable
fun DisposableEffectExample() {// 使用 DisposableEffect 来管理资源DisposableEffect(Unit) {// 在组合创建时执行初始化操作，这里可以初始化一些资源，比如打开文件、注册广播接收器等println("Effect started")// 定义一个销毁操作，当组合被销毁时会调用这个操作，用于释放之前初始化的资源onDispose {println("Effect disposed")}}Text(text = "DisposableEffect Example")
}

在这个示例中，DisposableEffect 接收一个 Unit 作为键，这意味着该副作用只在组合创建时执行一次。在 DisposableEffect 的 lambda 表达式中，我们可以执行初始化操作，同时通过 onDispose 函数定义资源清理操作。

3.2 DisposableEffect 函数的源码详细解析

DisposableEffect 函数的源码如下：

kotlin

/*** 创建一个副作用，该副作用在组合创建时执行，在组合销毁时清理。** @param key1 用于判断是否需要重新执行副作用的键，如果键发生变化，副作用会重新执行。* @param effect 副作用操作的 lambda 表达式，该表达式需要返回一个销毁操作的 lambda 表达式。*/
@Composable
fun DisposableEffect(key1: Any?,effect: DisposableEffectScope.() -> Disposable?
) {// 获取当前的组合上下文val current = currentComposer// 开始一个可替换的组，用于管理组合的状态current.startReplaceableGroup(0x728c2a2d)// 使用 remember 函数来记住副作用的状态val disposableHolder = remember(key1) {// 创建一个 DisposableHolder 对象，用于持有销毁操作DisposableHolder()}// 检查是否需要重新执行副作用if (disposableHolder.key != key1) {// 如果需要重新执行，先调用之前的销毁操作disposableHolder.dispose()// 执行新的副作用操作disposableHolder.disposable = effect(DisposableEffectScopeImpl())// 更新键disposableHolder.key = key1}// 结束可替换的组current.endReplaceableGroup()// 在组合销毁时调用销毁操作DisposableEffectImpl(disposableHolder)
}

  • 参数分析：

    • key1：这是一个用于判断是否需要重新执行副作用的关键参数。如果 key1 的值发生了变化，那么副作用就会重新执行。通过合理设置 key1，可以避免不必要的副作用重复执行，提高应用的性能。
    • effect：这是一个副作用操作的 lambda 表达式，该表达式需要返回一个销毁操作的 lambda 表达式。在这个 lambda 表达式中，我们可以执行初始化操作，同时定义在组合销毁时需要执行的清理操作。

  • 返回值说明：该函数没有返回值。

  • 实现细节剖析：

    1. 首先，通过 currentComposer 获取当前的组合上下文，这个上下文用于管理组合的状态。
    2. 接着，调用 startReplaceableGroup 方法开始一个可替换的组，这有助于管理组合的状态。
    3. 使用 remember 函数来记住 DisposableHolder 对象，该对象用于持有销毁操作。remember 函数可以确保在组合重建时，DisposableHolder 对象不会被重新创建，从而避免不必要的资源浪费。
    4. 检查 key1 是否发生变化，如果发生变化，说明需要重新执行副作用。此时，先调用之前的销毁操作，然后执行新的副作用操作，并更新 key1 的值。
    5. 调用 endReplaceableGroup 方法结束可替换的组。
    6. 最后，在组合销毁时调用 DisposableEffectImpl 函数，该函数会调用 DisposableHolder 对象的销毁操作，确保资源被正确释放。

3.3 DisposableEffectScope 接口的源码分析

DisposableEffectScope 接口定义了 DisposableEffect 的作用域，其源码如下：

kotlin

/*** DisposableEffect 的作用域接口。*/
interface DisposableEffectScope {/*** 定义一个销毁操作，当组合被销毁时会调用这个操作。** @param onDispose 销毁操作的 lambda 表达式。* @return 一个 Disposable 对象，用于表示销毁操作。*/fun onDispose(onDispose: () -> Unit): Disposable
}

  • 方法解析：

    • onDispose：该方法用于定义销毁操作，当组合被销毁时会调用这个操作。它接收一个 lambda 表达式作为参数，并返回一个 Disposable 对象，这个对象代表了销毁操作。通过这个方法，我们可以在组合销毁时执行一些必要的清理操作，如关闭文件、取消注册广播接收器等。

3.4 Disposable 接口的源码分析

Disposable 接口定义了一个销毁操作，其源码如下：

kotlin

/*** 定义一个销毁操作的接口。*/
interface Disposable {/*** 执行销毁操作。*/fun dispose()
}

  • 方法说明：

    • dispose：该方法用于执行销毁操作。实现了 Disposable 接口的类需要实现这个方法，在方法中编写具体的销毁逻辑，如释放资源、取消任务等。

3.5 DisposableEffectImpl 函数的源码分析

DisposableEffectImpl 函数用于在组合销毁时调用销毁操作，其源码如下：

kotlin

/*** 在组合销毁时调用销毁操作。** @param disposableHolder 持有销毁操作的 DisposableHolder 对象。*/
@Composable
private fun DisposableEffectImpl(disposableHolder: DisposableHolder) {// 获取当前的组合上下文val current = currentComposer// 开始一个可替换的组current.startReplaceableGroup(0x728c2a2e)// 在组合销毁时调用销毁操作DisposableEffect(Unit) {onDispose {disposableHolder.dispose()}}// 结束可替换的组current.endReplaceableGroup()
}

  • 参数说明：

    • disposableHolder：这是一个持有销毁操作的 DisposableHolder 对象。通过这个对象，我们可以在组合销毁时调用其 dispose 方法，执行具体的销毁操作。

  • 实现细节：

    1. 获取当前的组合上下文 currentComposer。
    2. 调用 startReplaceableGroup 方法开始一个可替换的组。
    3. 使用 DisposableEffect 函数在组合销毁时调用 disposableHolder 的 dispose 方法，确保资源被正确释放。
    4. 调用 endReplaceableGroup 方法结束可替换的组。

3.6 DisposableHolder 类的源码分析

DisposableHolder 类用于持有销毁操作，其源码如下：

kotlin

/*** 用于持有销毁操作的类。*/
private class DisposableHolder {// 持有销毁操作的 Disposable 对象var disposable: Disposable? = null// 用于判断是否需要重新执行副作用的键var key: Any? = null/*** 执行销毁操作。*/fun dispose() {disposable?.dispose()disposable = null}
}

  • 属性说明：

    • disposable：该属性持有销毁操作的 Disposable 对象，通过这个对象可以执行具体的销毁操作。
    • key：该属性用于判断是否需要重新执行副作用。当 key 的值发生变化时，会重新执行副作用。

  • 方法说明：

    • dispose：该方法用于执行销毁操作。它会调用 disposable 对象的 dispose 方法，并将 disposable 置为 null，确保资源被正确释放。

四、LaunchedEffect 的使用与源码深度解析

4.1 LaunchedEffect 的基础使用示例

LaunchedEffect 是一个专门用于在组合生命周期的特定阶段启动异步任务的 Composable 函数。以下是一个简单的示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay@Composable
fun LaunchedEffectExample() {// 使用 LaunchedEffect 启动一个异步任务LaunchedEffect(Unit) {// 模拟一个异步操作，比如网络请求、数据库查询等delay(1000)println("Async operation completed")}Text(text = "LaunchedEffect Example")
}

在这个示例中，LaunchedEffect 接收一个 Unit 作为键，这意味着该异步任务只在组合创建时启动一次。在 LaunchedEffect 的 lambda 表达式中，我们可以使用协程来执行异步操作。

4.2 LaunchedEffect 函数的源码详细解析

LaunchedEffect 函数的源码如下：

kotlin

/*** 在组合生命周期的特定阶段启动一个协程。** @param key1 用于判断是否需要重新启动协程的键，如果键发生变化，协程会重新启动。* @param block 协程的执行体，是一个挂起函数。*/
@Composable
fun LaunchedEffect(key1: Any?,block: suspend CoroutineScope.() -> Unit
) {// 获取当前的组合上下文val current = currentComposer// 开始一个可替换的组current.startReplaceableGroup(0x728c2a2f)// 获取当前的协程作用域val coroutineScope = currentComposer.coroutineScope// 使用 remember 函数来记住协程的状态val jobHolder = remember(key1) {// 创建一个 JobHolder 对象，用于持有协程的 JobJobHolder()}// 检查是否需要重新启动协程if (jobHolder.key != key1) {// 如果需要重新启动，先取消之前的协程jobHolder.job?.cancel()// 启动新的协程jobHolder.job = coroutineScope.launch(block = block)// 更新键jobHolder.key = key1}// 结束可替换的组current.endReplaceableGroup()// 在组合销毁时取消协程DisposableEffect(Unit) {onDispose {jobHolder.job?.cancel()}}
}

  • 参数分析：

    • key1：用于判断是否需要重新启动协程的键。如果 key1 的值发生变化，协程会重新启动。通过合理设置 key1，可以避免不必要的协程重复启动，提高应用的性能。
    • block：协程的执行体，是一个挂起函数。在这个挂起函数中，我们可以编写异步操作的代码，如网络请求、数据库查询等。

  • 返回值说明：该函数没有返回值。

  • 实现细节剖析：

    1. 获取当前的组合上下文 currentComposer，用于管理组合的状态。
    2. 调用 startReplaceableGroup 方法开始一个可替换的组。
    3. 获取当前的协程作用域 coroutineScope，通过这个作用域可以启动协程。
    4. 使用 remember 函数来记住 JobHolder 对象，该对象用于持有协程的 Job。remember 函数可以确保在组合重建时，JobHolder 对象不会被重新创建，从而避免不必要的资源浪费。
    5. 检查 key1 是否发生变化，如果发生变化，说明需要重新启动协程。此时，先取消之前的协程，然后启动新的协程，并更新 key1 的值。
    6. 调用 endReplaceableGroup 方法结束可替换的组。
    7. 使用 DisposableEffect 函数在组合销毁时取消协程，确保协程在不需要时被及时取消，避免资源浪费。

4.3 JobHolder 类的源码分析

JobHolder 类用于持有协程的 Job，其源码如下：

kotlin

/*** 用于持有协程的 Job 的类。*/
private class JobHolder {// 持有协程的 Jobvar job: Job? = null// 用于判断是否需要重新启动协程的键var key: Any? = null
}

  • 属性说明：

    • job：该属性持有协程的 Job，通过这个 Job 对象可以控制协程的生命周期，如取消协程等。
    • key：该属性用于判断是否需要重新启动协程。当 key 的值发生变化时，会重新启动协程。

五、DisposableEffect 和 LaunchedEffect 的实际应用场景

5.1 DisposableEffect 的应用场景

5.1.1 资源管理

在 Android 开发中，很多资源需要在使用完毕后进行释放，例如文件句柄、数据库连接、广播接收器等。DisposableEffect 可以帮助我们在组合创建时初始化这些资源，在组合销毁时释放这些资源。以下是一个注册广播接收器的示例：

kotlin

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext@Composable
fun BroadcastReceiverExample() {// 获取当前的上下文val context = LocalContext.current// 使用 DisposableEffect 来管理广播接收器DisposableEffect(Unit) {// 创建一个广播接收器val receiver = object : BroadcastReceiver() {override fun onReceive(context: Context, intent: Intent) {println("Received broadcast: ${intent.action}")}}// 注册广播接收器val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)context.registerReceiver(receiver, filter)// 定义销毁操作，在组合销毁时取消注册广播接收器onDispose {context.unregisterReceiver(receiver)}}Text(text = "Broadcast Receiver Example")
}
5.1.2 动画资源管理

在 Android Compose 中，动画也需要进行资源管理。例如，当动画不再需要时，需要停止动画并释放相关资源。DisposableEffect 可以帮助我们在组合销毁时停止动画。以下是一个简单的动画示例：

kotlin

import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@Composable
fun AnimationResourceManagementExample() {// 定义一个动画值val animatedValue = rememberInfiniteTransition().animateFloat(initialValue = 0f,targetValue = 1f,animationSpec = infiniteRepeatable(animation = tween(durationMillis = 1000),repeatMode = RepeatMode.Reverse))// 使用 DisposableEffect 来管理动画资源DisposableEffect(Unit) {// 这里可以进行一些初始化操作// 定义销毁操作，在组合销毁时停止动画onDispose {// 目前没有直接停止 rememberInfiniteTransition 的方法，这里可以根据具体情况进行处理// 例如，取消相关的协程等}}Box(modifier = Modifier.size(100.dp).background(Color.Blue.copy(alpha = animatedValue.value))) {Text(text = "Animated Box")}
}

5.2 LaunchedEffect 的应用场景

5.2.1 网络请求

在 Android 应用中，网络请求是一个常见的异步操作。LaunchedEffect 可以帮助我们在组合创建时启动网络请求，并在组合销毁时取消请求。以下是一个简单的网络请求示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext// 模拟一个网络请求函数
suspend fun fetchData(): String {// 模拟网络延迟delay(1000)return "Data from network"
}@Composable
fun NetworkRequestExample() {// 定义一个状态来保存网络请求的结果var data by remember { mutableStateOf<String?>(null) }// 使用 LaunchedEffect 启动网络请求LaunchedEffect(Unit) {try {// 执行网络请求val result = fetchData()// 更新状态data = result} catch (e: Exception) {// 处理异常println("Network request error: ${e.message}")}}if (data != null) {Text(text = data!!)} else {Text(text = "Loading...")}
}
5.2.2 数据库查询

在 Android 应用中，数据库查询也是一个常见的异步操作。LaunchedEffect 可以帮助我们在组合创建时启动数据库查询，并在组合销毁时取消查询。以下是一个简单的数据库查询示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext// 模拟一个数据库查询函数
suspend fun queryDatabase(): List<String> {// 模拟数据库查询延迟delay(1000)return listOf("Data 1", "Data 2", "Data 3")
}@Composable
fun DatabaseQueryExample() {// 定义一个状态来保存数据库查询的结果var data by remember { mutableStateOf<List<String>?>(null) }// 使用 LaunchedEffect 启动数据库查询LaunchedEffect(Unit) {try {// 执行数据库查询val result = queryDatabase()// 更新状态data = result} catch (e: Exception) {// 处理异常println("Database query error: ${e.message}")}}if (data != null) {data!!.forEach { item ->Text(text = item)}} else {Text(text = "Loading...")}
}

六、DisposableEffect 和 LaunchedEffect 的性能优化策略

6.1 减少不必要的副作用执行

在使用 DisposableEffect 和 LaunchedEffect 时，应尽量减少不必要的副作用执行。可以通过合理设置键来避免副作用的重复执行。例如，在 DisposableEffect 中，如果某个资源只需要在组合创建时初始化一次，可以使用 Unit 作为键：

kotlin

DisposableEffect(Unit) {// 初始化资源println("Resource initialized")onDispose {// 释放资源println("Resource disposed")}
}

6.2 优化协程的使用

在使用 LaunchedEffect 启动协程时，应注意协程的使用效率。可以使用 withContext 函数来切换协程的上下文，避免在主线程中执行耗时操作。例如：

kotlin

LaunchedEffect(Unit) {withContext(Dispatchers.IO) {// 在 IO 线程中执行耗时操作，如网络请求、数据库查询等val result = fetchData()withContext(Dispatchers.Main) {// 切换回主线程更新 UIdata = result}}
}

6.3 避免内存泄漏

在使用 DisposableEffect 和 LaunchedEffect 时，应注意避免内存泄漏。确保在组合销毁时正确释放资源和取消协程。例如，在 DisposableEffect 中，通过 onDispose 函数释放资源；在 LaunchedEffect 中，通过 DisposableEffect 函数在组合销毁时取消协程。

七、DisposableEffect 和 LaunchedEffect 的常见问题及解决方案

7.1 副作用重复执行问题

有时候，可能会遇到副作用重复执行的问题。这可能是由于键的设置不合理导致的。解决方案是确保键的设置正确，只有在需要重新执行副作用时才改变键的值。例如：

kotlin

var counter by remember { mutableStateOf(0) }
DisposableEffect(counter) {// 只有当 counter 发生变化时，副作用才会重新执行println("Effect executed with counter: $counter")onDispose {println("Effect disposed")}
}Button(onClick = { counter++ }) {Text("Increment Counter")
}

7.2 协程未取消问题

在使用 LaunchedEffect 启动协程时，如果协程没有在组合销毁时取消，可能会导致内存泄漏。解决方案是确保在组合销毁时正确取消协程。例如：

kotlin

LaunchedEffect(Unit) {val job = launch {// 执行异步操作delay(10000)println("Async operation completed")}// 在组合销毁时取消协程DisposableEffect(Unit) {onDispose {job.cancel()}}
}

7.3 资源未释放问题

在使用 DisposableEffect 管理资源时，如果资源没有在组合销毁时释放，可能会导致资源泄漏。解决方案是确保在 onDispose 函数中正确释放资源。例如：

kotlin

DisposableEffect(Unit) {// 打开文件val file = File("example.txt")val stream = file.outputStream()onDispose {// 关闭文件流stream.close()}
}

八、DisposableEffect 和 LaunchedEffect 的扩展应用

8.1 自定义副作用函数

可以基于 DisposableEffect 和 LaunchedEffect 自定义副作用函数，以满足特定的需求。以下是一个自定义的 NetworkRequestEffect 函数：

kotlin

import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import kotlinx.coroutines.*// 自定义的网络请求副作用函数
@Composable
fun NetworkRequestEffect(url: String,onSuccess: (String) -> Unit,onError: (Exception) -> Unit
) {LaunchedEffect(url) {try {// 模拟网络请求val result = fetchDataFromNetwork(url)onSuccess(result)} catch (e: Exception) {onError(e)}}
}// 模拟网络请求函数
suspend fun fetchDataFromNetwork(url: String): String {delay(1000)return "Data from $url"
}@Composable
fun CustomEffectExample() {var data by rememberSaveable { mutableStateOf<String?>(null) }var error by rememberSaveable { mutableStateOf<String?>(null) }NetworkRequestEffect(url = "https://example.com",onSuccess = { result ->data = resulterror = null},onError = { e ->error = e.messagedata = null})if (data != null) {Text(text = data!!)} else if (error != null) {Text(text = "Error: $error")} else {Text(text = "Loading...")}
}

8.2 与其他 Compose 特性结合使用

DisposableEffect 和 LaunchedEffect 可以与其他 Compose 特性结合使用，例如动画、布局等。以下是一个与动画结合的示例：

kotlin

import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp@Composable
fun AnimationAndEffectExample() {// 定义一个动画值val animatedValue = rememberInfiniteTransition().animateFloat(initialValue = 0f,targetValue = 1f,animationSpec = infiniteRepeatable(animation = tween(durationMillis = 1000),repeatMode = RepeatMode.Reverse))// 使用 LaunchedEffect 启动一个协程来处理动画的一些逻辑LaunchedEffect(animatedValue.value) {if (animatedValue.value > 0.5f) {println("Animated value is greater than 0.5")}}Box(modifier = Modifier.size(100.dp).background(Color.Blue.copy(alpha = animatedValue.value))) {Text(text = "Animated Box")}
}

九、DisposableEffect 和 LaunchedEffect 与 Android 生命周期的关联

9.1 Android 生命周期概述

在 Android 开发中，Activity 和 Fragment 都有自己的生命周期。Activity 的生命周期包括 onCreate、onStart、onResume、onPause、onStop、onDestroy 等方法；Fragment 的生命周期包括 onCreate、onCreateView、onViewCreated、onStart、onResume、onPause、onStop、onDestroyView、onDestroy 等方法。了解 Android 生命周期对于正确使用 DisposableEffect 和 LaunchedEffect 非常重要。

9.2 DisposableEffect 和 LaunchedEffect 与 Android 生命周期的映射

在 Android Compose 中，DisposableEffect 和 LaunchedEffect 可以与 Android 生命周期的某些阶段进行映射。例如，DisposableEffect 可以在组合创建时执行初始化操作，在组合销毁时执行清理操作，类似于 Activity 的 onCreate 和 onDestroy 方法；LaunchedEffect 可以在组合创建时启动异步任务，在组合销毁时取消任务，类似于 Activity 的 onStart 和 onStop 方法。

9.3 示例代码

kotlin

import androidx.activity.ComponentActivity
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwnerclass MainActivity : ComponentActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContent {LifecycleExample()}}
}@Composable
fun LifecycleExample() {// 获取当前的 LifecycleOwnerval lifecycleOwner = LocalLifecycleOwner.current// 使用 DisposableEffect 监听 Android 生命周期DisposableEffect(lifecycleOwner) {val observer = LifecycleEventObserver { _, event ->when (event) {Lifecycle.Event.ON_START -> {println("Activity started")}Lifecycle.Event.ON_STOP -> {println("Activity stopped")}else -> {}}}// 注册生命周期观察者lifecycleOwner.lifecycle.addObserver(observer)// 在组合销毁时取消注册生命周期观察者onDispose {lifecycleOwner.lifecycle.removeObserver(observer)}}Text(text = "Lifecycle Example")
}

十、DisposableEffect 和 LaunchedEffect 的高级应用场景

10.1 多条件触发的副作用

在实际开发中，可能需要根据多个条件来触发副作用。可以通过组合多个键来实现这一功能。以下是一个示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.material.Button
import androidx.compose.runtime.Composable@Composable
fun MultiConditionEffectExample() {var condition1 by remember { mutableStateOf(false) }var condition2 by remember { mutableStateOf(false) }DisposableEffect(condition1, condition2) {if (condition1 && condition2) {println("Both conditions are true, side effect triggered")}onDispose {println("Side effect disposed")}}Button(onClick = { condition1 = !condition1 }) {Text("Toggle Condition 1")}Button(onClick = { condition2 = !condition2 }) {Text("Toggle Condition 2")}
}

10.2 嵌套使用 DisposableEffect 和 LaunchedEffect

在某些复杂的场景中，可能需要嵌套使用 DisposableEffect 和 LaunchedEffect。例如，在一个 LaunchedEffect 中启动一个异步任务，同时使用 DisposableEffect 来管理异步任务中使用的资源。以下是一个示例：

kotlin

import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay@Composable
fun NestedEffectExample() {LaunchedEffect(Unit) {// 启动一个异步任务val job = launch {delay(2000)println("Async task completed")}DisposableEffect(job) {// 管理异步任务中使用的资源println("Resource initialized for async task")onDispose {// 在组合销毁时取消异步任务并释放资源job.cancel()println("Resource disposed for async task")}}}Text(text = "Nested Effect Example")
}

十一、总结与展望

11.1 总结

通过对 DisposableEffect 和 LaunchedEffect 的全面深入分析，我们清晰地认识到它们在 Android Compose 组合生命周期管理中扮演的关键角色。DisposableEffect 专注于资源的管理，确保资源在组合创建时被正确初始化，在组合销毁时被及时释放，有效地避免了资源泄漏和浪费问题。而 LaunchedEffect 则擅长处理异步任务，它能够在组合创建时启动异步任务，并在组合销毁时取消任务，保证了异步操作的高效性和安全性。同时，我们还探讨了它们的多种应用场景，包括资源管理、网络请求、数据库查询等，以及性能优化策略、常见问题的解决方案和扩展应用。这些知识和技巧对于开发者来说至关重要，能够帮助他们更好地利用 DisposableEffect 和 LaunchedEffect 来构建高性能、稳定的 Android Compose 应用。

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

相关资讯

热文排行

最新新闻

推荐新闻

热搜词