从 View 体系切换到 Jetpack Compose,大多数安卓开发者遇到的第一个真正意义上的“分水岭”,不是怎么写布局,而是怎么管状态。写界面很容易,让界面跟随数据变化、并且在大规模页面里不乱,才是难点。
在传统 View 体系里,我们习惯拿到控件实例后手动更新,findViewById 拿 TextView,再调 setText。到了 Compose,没有控件实例可以改,UI 是函数对状态的“投影”。数据变了,界面就该自动重新描述自己。听起来很美好,可一旦真正开始写复杂页面,你很快会撞上这些现象:数据明明改了,界面却不动;一滚动整页被重新测量;旋转屏幕后计数器莫名其妙清零。
这个系列的定位是“搬运+中文讲解”,前面几篇已经把声明式 UI 的基本语法和布局体系讲了一遍。到了第 6 篇,终于要进入最容易被绕晕的部分:状态管理。这篇文章不打算只罗列 API,而是想把状态管理的底层逻辑、常用 API、工程化写法一次讲清楚。读完你会明白 remember、rememberSaveable、ViewModel、StateFlow 到底各自解决什么问题,也能够在实际项目中做出更合理的选择。
1. 状态管理:Compose 学习路上的第一道坎
1.1 为什么是“状态管理”,而不是“怎么写 UI”
如果你只是照着官方示例写一个 Text 或 Button,你会觉得 Compose 很简单。但真实应用不是静态页面,它要响应输入、网络返回、数据库变化、用户操作等一连串事件。这里最大的转变在于:不再是“我主动去改界面”,而是“界面根据状态自动重新计算”。
Compose 的状态管理,解决的核心问题就是:状态发生变化时,哪些 UI 需要更新,以及如何避免不必要的更新。
很多初学者会把 Compose 的“自动更新”理解成黑魔法:反正数据变了界面就会变,至于怎么变的,交给框架就好。这种理解在写小 Demo 时没问题,一旦页面复杂,就会出现三种典型信号:
- 更新不及时,状态改了界面纹丝不动;
- 更新过度,一个文本变化导致整个列表重组;
- 更新丢失,Activity 被重建后用户输入全部消失。
这三种问题,表面看是写法问题,本质都是没有理解 Compose 状态管理的几个核心机制。所以这篇文章会先从原理讲起,再落到代码。
1.2 本文能帮你解决什么问题
如果你正准备从 View 体系转向 Compose,或者已经写了几个 Compose 页面但心里没底,这篇文章非常适合你。
具体来说,读完你会得到四样东西:
- 理解状态、重组、状态提升、单向数据流这些概念,不再被术语劝退;
- 掌握 Compose 本地状态工具
remember和rememberSaveable,知道它们能存什么、不能存什么; - 掌握 ViewModel + StateFlow 的组合方式,能够处理页面级和跨页面的状态;
- 避开自己在实际项目中容易踩的坑,比如列表状态不刷新、重组频繁、旋转屏幕丢状态等。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 必须先读懂:状态、重组与单向数据流
2.1 状态:UI 的唯一输入
先用一句话概括 Compose 的模型:UI 是状态的函数。 状态变了,UI 就会以新的状态为输入,重新生成一份界面描述。
这里的“状态”不是抽象概念,在代码里它通常对应一个可以被 Compose 观察的对象。最基础的状态类型是:
kotlin复制val count = mutableStateOf(0)
这段代码创建了一个可观察状态 count,count.value 就是当前值。Compose 的运行时会在两个方向工作:
- 当某个 Composable 读取了这个状态的值,它就被注册为“依赖这个状态”;
- 当这个状态的值被修改,Compose 会让所有依赖它的 Composable 进入重组流程。
这句话是理解 Compose 的钥匙。注意,是“读取了状态的 Composable 会重组”,而不是“整个页面都重组”,也不是“所有变量都重新初始化”。
2.2 重组:Compose 的自动更新到底是怎么发生的
重组(Recomposition)是 Compose 更新 UI 的机制。当状态变化时,Compose 不会重新创建整个 Activity,也不会清空所有 UI,而是只重新执行那些“读到了这个状态”的 Composable 函数。
举个具体例子:
kotlin复制@Composable
fun HelloContent() {
var name by remember { mutableStateOf("Android") }
Row {
Text(text = "当前名字:$name")
Button(onClick = { name = "Compose" }) {
Text("改名字")
}
}
}
在这个例子中,name 被 Text(text = "当前名字:$name") 读取了。所以当按钮点击把 name 改成 Compose 时,只有那个 Text 会发生重组。Row 本身和 Button 如果参数没有变化,就不会重新执行。
这里容易出现一个误区:Button(onClick = { name = "Compose" }) 里的 lambda 在每次重组时都会被创建,但这不意味着 Button 一定会重组。重组与否取决于参数是否变化,以及 Compose 能否判断参数稳定。
还有一点很重要:重组是“可跳过”的,但不是说每次状态变化都会精准到单个 Text。 实际工程中,如果 Composable 的参数不够稳定,或者读取状态的范围太大,重组范围会被放大。这就是之后要讨论性能问题的原因。
2.3 状态提升与单向数据流
在可组合函数内部用 remember 保存状态,是本地状态。但在真实项目中,状态经常需要在多个 Composable 之间共享。Compose 给出的答案是:把状态往上提。
状态提升(State Hoisting)的含义是:把状态从子组件中移出来,放到父级组件中,然后通过参数传给子组件;子组件自己不保存状态,只负责展示和回调。
这形成了 Compose 反复强调的“单向数据流”:
- 状态向下传递:父组件通过参数把状态传给子组件;
- 事件向上传递:子组件通过回调把用户操作结果交给父组件修改状态。
举个最典型的例子,TextField 的写法:
kotlin复制@Composable
fun NameField(
value: String,
onValueChange: (String) -> Unit
) {
TextField(
value = value,
onValueChange = onValueChange
)
}
NameField 自己并不保存输入内容,它只是把 value 展示出来,然后把输入事件通过 onValueChange 交出去。谁拥有状态,谁决定状态怎么变。这种设计让组件变得无状态、可复用、可测试。
可以这么理解:状态提升其实就是 Android 开发里“单一数据源”思想的 Compose 版本。不要在多个组件里各存一份容易不同步的副本,而是让数据从一个地方流向界面。
3. remember 与 rememberSaveable:两种本地状态工具
3.1 最简单的计数器:remember + mutableStateOf
remember 是 Compose 中用途最广的本地状态工具。它解决的问题是:在重组时保留计算结果,而不是每次重新计算。
最常见的组合是 remember + mutableStateOf。写一个最经典的计数器 Demo:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/CounterScreen.kt
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
@Composable
fun CounterScreen() {
var count by remember { mutableStateOf(0) }
Column {
Text(text = "当前计数:$count")
Spacer(modifier = Modifier.height(16.dp))
Button(onClick = { count++ }) {
Text("点我加 1")
}
}
}
这里的 by 是 Kotlin 的属性委托,它让 count 可以直接用赋值语法更新。编译后,它等价于:
kotlin复制val countState = remember { mutableStateOf(0) }
val count = countState.value
// 更新时:countState.value = countState.value + 1
用 by 书写更简洁,是 Compose 项目的常见风格。但要注意,读取和写入状态都会受到检测。如果你在某个 Composable 里读取了 count,那么 count 变化时这个 Composable 就会重组,这是预期行为。
3.2 为什么旋转屏幕后状态会丢:rememberSaveable
remember 有一个明显的局限:它只能保证当前组合(composition)生命周期内的状态。Activity 因为旋转屏幕而重建,或者系统在后台回收了进程,组合会消失,remember 里的状态也就一并丢了。
要解决这个问题,Compose 提供了 rememberSaveable。它比 remember 多做了持久化的工作:在配置变更和进程重建时,把状态存入 Bundle,恢复时再取出来。
上面计数器的代码,只需要改一行:
kotlin复制var count by rememberSaveable { mutableStateOf(0) }
现在旋转屏幕,计数不会归零。
需要注意,rememberSaveable 不是万能的。它存的数据必须能被放进 Bundle,也就是原生支持的基本类型、Parcelable、Serializable 等。如果是一个自定义的普通对象,直接塞进去会抛异常。此时需要用自定义 Saver 把对象拆成可保存的字段,或者干脆用 ViewModel 来存。
3.3 本地状态的使用边界
remember 和 rememberSaveable 适合保存 UI 层面的临时状态,比如输入框的文本、开关的选中状态、一个已经展开的列表项 ID。
它们不适合保存什么?
- 不应该保存从网络获取的业务数据。业务数据应该放在 ViewModel 或数据层,否则进程一旦回收,界面恢复时还得重新请求。
- 不应该保存需要跨多个页面共享的数据。
remember在组合销毁后就不存在了,跨页面共享应该交给更上层。 - 不应该保存大量对象,尤其是大列表。
Bundle对 Parcelable 序列化有性能成本,放几百条数据进去容易造成卡顿。
判断标准很简单:如果这个状态消失后,重新创建它的成本很低,放本地没问题;如果它代表用户的业务状态,放本地就不合适。
4. 状态提升实战:让输入框的数据“可掌控”
4.1 问题场景:TextField 的输入状态
如果你直接使用 TextField 却能显示用户输入,这是因为它内部自己保存了状态。但这种写法有个问题:你拿不到输入内容,也没法修改它。等你想加一个“清空”按钮,或者想根据输入内容实时校验时,就发现无从下手。
正确做法是状态提升。用一个“名 + 姓”输入的示例来说明。
4.2 无状态子组件 + 有状态父组件
先定义一个无状态的子组件,它只负责接收 value 并回调 onValueChange:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/FullNameScreen.kt
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun NameField(
label: String,
value: String,
onValueChange: (String) -> Unit,
modifier: Modifier = Modifier
) {
Column(modifier = modifier) {
Text(text = label)
TextField(
value = value,
onValueChange = onValueChange,
singleLine = true
)
}
}
父组件持有真正的状态,并把状态和回调传下去:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/FullNameScreen.kt
import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.mutableStateOf
@Composable
fun FullNameScreen() {
var firstName by rememberSaveable { mutableStateOf("") }
var lastName by rememberSaveable { mutableStateOf("") }
Column(modifier = Modifier.padding(16.dp)) {
NameField(
label = "名",
value = firstName,
onValueChange = { firstName = it },
modifier = Modifier.fillMaxWidth()
)
NameField(
label = "姓",
value = lastName,
onValueChange = { lastName = it },
modifier = Modifier.fillMaxWidth()
)
Text(text = "完整姓名:${firstName.trim()} ${lastName.trim()}")
}
}
这个例子演示了状态提升的完整结构。NameField 是无状态组件,不管传入的值来自哪里,自己也不去修改;FullNameScreen 是有状态组件,拥有两个状态变量,并提供回调更新它们。
4.3 为什么推荐状态提升
有人会问:直接在 NameField 内部写 var value by remember { mutableStateOf("") } 不是更简单吗?从 Demo 看确实更简单,但一旦业务复杂起来,会立刻暴露出问题:
- 如果两个输入框之间需要联动,子组件内部各存各的,很难同步;
- 如果需要对用户的输入做统一处理或校验,父组件拿不到数据;
- 如果以后要把这个组件抽出来复用,内部状态会变成“黑盒”,调用方无法控制。
状态提升把“数据在哪里”的决策权交还给架构。对于团队协作来说,也更容易约定哪些 Composable 是纯展示组件,哪些是状态容器。
当然,也不是所有状态都必须提升到顶层。remember 适合保留在真正需要它的组件内部,如果一个状态只影响当前组件的显示逻辑,没必要一路提升到底。关键是找到一个“够用就好”的层级。
5. ViewModel + StateFlow:复杂页面的状态管理方案
5.1 ViewModel 在 Compose 中的定位
rememberSaveable 能解决配置变更,但解决不了真正的业务状态管理。业务状态往往需要跨页面共享、需要存活到任务完成、需要在网络请求结束后更新。这时候 ViewModel 是更合理的宿主。
ViewModel 的生命周期不随组合销毁而结束。它由 ViewModelStore 管理,Activity 或 Fragment 重建后仍然保留。在 Compose 中,可以通过 viewModel() 函数方便地获取:
kotlin复制val viewModel: CounterViewModel = viewModel()
View Model 里应该放什么?放业务状态,以及修改业务状态的方法。它不应该持有任何 UI 引用,也不应该知道 Activity 是否存在。这样即使组合销毁又重建,状态依然存在。
5.2 用 StateFlow 管理计数器的状态
传统写法是在 ViewModel 中暴露 LiveData,在 Compose 中也可以如此。但更推荐的是 StateFlow,因为 StateFlow 是 Kotlin 协程层面的 Flow,天然支持 collectAsState 这样的 Compose 桥接 API。
先定义一个计数器 ViewModel:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/CounterViewModel.kt
import androidx.lifecycle.ViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
class CounterViewModel : ViewModel() {
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count.asStateFlow()
fun increment() {
_count.value += 1
}
}
在 Compose 侧订阅状态:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/CounterRoute.kt
import androidx.compose.runtime.getValue
import androidx.compose.runtime.collectAsState
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun CounterRoute(viewModel: CounterViewModel = viewModel()) {
val count by viewModel.count.collectAsStateWithLifecycle()
Column {
Text(text = "当前计数:$count")
Spacer(modifier = Modifier.height(16.dp))
Button(onClick = { viewModel.increment() }) {
Text("点我加 1")
}
}
}
这里 UI 不直接修改 count,而是调用 viewModel.increment()。状态从 ViewModel 流到 UI,更新事件的源头则是用户的点击操作。这样即使 Activity 重建,ViewModel 中的计数不会归零。
5.3 为什么直接持有 MutableStateFlow 不推荐
新手容易写出这样的代码:把 MutableStateFlow 直接暴露给 UI,然后在 UI 层直接改 viewModel.count.value++。这不是不能运行,但会破坏封装。
ViewModel 的存在意义,是集中管理业务逻辑。如果 UI 能直接改状态,等于业务规则散落在各个 Composable 里。等业务复杂到需要统一校验、组合多个状态时,代码会变得不可控。
更推荐的是暴露只读的 StateFlow:
kotlin复制private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count.asStateFlow()
UI 只能观察 count,所有修改都必须经过 ViewModel 提供的方法。这是单向数据流在 ViewModel 层的体现。
5.4 需要引入哪些依赖
实际项目中使用 ViewModel 和 Compose 时需要添加如下依赖,版本号以当前项目为准:
gradle复制// app/build.gradle.kts 或 app/build.gradle
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:${lifecycleVersion}")
implementation("androidx.lifecycle:lifecycle-runtime-compose:${lifecycleVersion}")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:${coroutinesVersion}")
lifecycle-viewmodel-compose 提供 viewModel(),lifecycle-runtime-compose 提供 collectAsStateWithLifecycle。如果你暂时不想引入这些库,也可以先使用 collectAsState(),它属于 Compose Runtime 的一部分,但生命周期处理没有前者完善。
6. Flow 与生命周期安全:列表加载的完整示例
6.1 从 Flow 到 Compose 的桥接
StateFlow 是 Flow 家族中适合保存状态的那一个。它总是持有当前值,新订阅者一进来就能拿到最新数据。与之对应,普通 Flow 更适合描述“一次性的数据流”,比如网络请求返回、用户事件队列等。
从 Compose 角度,最常用到的两个收集方法是:
collectAsState():把一个 Flow 转换成 Compose 的 State,简单直接;collectAsStateWithLifecycle():考虑生命周期安全,在 STOP 时停止收集,回到 START 时自动恢复。
后者来自 lifecycle-runtime-compose。在实际项目中,推荐优先使用它,理由很简单:避免在后台状态下无意义地更新 UI,减少内存和 CPU 消耗。
6.2 用户列表加载示例
写一个稍完整一点的示例:从 ViewModel 加载用户列表,在 Compose 中用 LazyColumn 展示。
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/UserListViewModel.kt
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
class UserListViewModel : ViewModel() {
private val _users = MutableStateFlow<List<String>>(emptyList())
val users: StateFlow<List<String>> = _users.asStateFlow()
private val _loading = MutableStateFlow(true)
val loading: StateFlow<Boolean> = _loading.asStateFlow()
init {
loadUsers()
}
private fun loadUsers() {
viewModelScope.launch {
_loading.value = true
// 这里模拟网络请求,真实项目中会调用 Repository
val result = fetchUsers()
_users.value = result
_loading.value = false
}
}
private suspend fun fetchUsers(): List<String> {
delay(1000)
return listOf("Alice", "Bob", "Charlie")
}
}
Compose 侧如下:
kotlin复制// 文件路径:app/src/main/java/com/example/composestate/UserListScreen.kt
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun UserListScreen(viewModel: UserListViewModel = viewModel()) {
val users by viewModel.users.collectAsStateWithLifecycle()
val loading by viewModel.loading.collectAsStateWithLifecycle()
if (loading) {
CircularProgressIndicator()
} else {
LazyColumn {
items(users) { user ->
Text(
text = user,
style = MaterialTheme.typography.bodyLarge,
modifier = Modifier.padding(16.dp)
)
}
}
}
}
这个示例包含了加载、成功两个基本状态。如果你有接口失败的场景,还可以继续扩展一个 error 字段,在 UI 侧根据状态展示错误页和重试按钮。
6.3 StateFlow 与普通 Flow 的区别
在这个例子中,users 使用 StateFlow 是因为它代表的是“当前状态”。如果列表被刷新,新数据会替换旧数据,UI 需要始终展示最新值。而如果你要做一次性的事件驱动,比如用户点击后弹一个 Snackbar,就不合适用 StateFlow,因为 StateFlow 会保留旧值,可能导致重复消费。
简单区分:
- 保存状态:用 StateFlow;
- 发送一次性事件:用 SharedFlow 或 Channel。
这条经验可以避免很多“事件被重复触发”“旧事件在新页面出现”的奇怪 bug。
7. 常见问题与排查思路
下面这张表整理了我认为新手最容易踩到的问题,以及对应的排查和解决路径。
| 问题现象 | 可能原因 | 排查方式 | 解决方案 |
|---|---|---|---|
| 数据改了,界面不刷新 | 状态不是 Compose 可观察状态,或没有用可变方式更新 | 检查是否用了 mutableStateOf、StateFlow;检查赋值位置 |
统一使用 mutableStateOf / StateFlow / mutableStateListOf |
| 旋转屏幕后状态丢失 | 使用了 remember,没有 rememberSaveable 或 ViewModel |
检查状态保存位置 | 需要 UI 临时状态用 rememberSaveable,业务状态用 ViewModel |
| 页面整体频繁重组 | 读取状态的位置太靠上层,传入了不稳定参数 | 使用 Layout Inspector 查看重组范围 | 缩小状态读取范围、使用派生状态、拆分 Composable |
| 修改 List 后列表不更新 | 用 mutableStateOf(mutableListOf()) 并调 add |
检查集合是否是快照感知集合 | 改用 mutableStateListOf,或创建新列表赋值 |
| 后台时仍然收集 Flow | 使用了 collectAsState,没有处理生命周期 |
检查是否导入了 lifecycle 库 | 使用 collectAsStateWithLifecycle |
| ViewModel 里 new 了 MutableStateFlow 但 UI 收不到 | 忘记 .asStateFlow() 或暴露了错误的 MutableStateFlow 类型 |
检查 ViewModel 暴露属性类型 | 对外暴露只读 StateFlow,内部持有 MutableStateFlow |
大量对象塞进 rememberSaveable 导致崩溃 |
rememberSaveable 存了 Bundle 不支持的属性 |
查看异常堆栈是否出现 Parcelable 相关错误 | 使用自定义 Saver,或把对象放入 ViewModel |
针对“修改 List 后列表不更新”,给出一个正误对比,这是很多人容易写错的地方:
kotlin复制// 错误的写法:mutableListOf 不是快照感知集合
var items by remember { mutableStateOf(mutableListOf("A")) }
fun addItem() {
items.add("B") // 状态对象没变,Compose 不会感知列表内部变化
}
kotlin复制// 正确的写法:mutableStateListOf 由 Compose 快照感知
val items = remember { mutableStateListOf("A") }
fun addItem() {
items.add("B") // 可以正常触发重组
}
或者换一种更函数式的写法:
kotlin复制var items by remember { mutableStateOf(listOf("A")) }
fun addItem() {
items = items + "B" // 生成新 List,触发状态变化
}
理解原因比记住结论更重要。Compose 的快照系统能感知的是 State 对象的 value 变化。当你使用普通 MutableList 时,调用 add 只是修改了 List 内部结构,State 持有的 List 引用并没有变化,所以 UI 不会更新。mutableStateListOf 是快照感知的集合,它的内部修改能被 Compose 检测到。
8. 最佳实践与工程建议
8.1 最小状态原则
不是所有值都值得放进状态里。如果一个值可以由其他状态计算得到,就不要额外保存它。典型例子是“列表是否为空”:
kotlin复制val isEmpty = users.isEmpty() // 不需要单独存一个状态
多余的状态会增加同步成本。两个状态本来应该同源,但因为在两处维护,业务代码稍有不慎就会产生不一致。更好的方式是只维护一个数据源,需要的派生值通过计算得到。
8.2 派生状态用 derivedStateOf
当某个状态频繁变化,但我们只想在派生结果真正变化时才触发 UI 更新,可以使用 derivedStateOf。最典型的场景是:列表数据变化时,按钮的可用状态只有“可点击”和“不可点击”两种结果,没必要每次数据变都重组按钮。
kotlin复制val isSubmitEnabled by remember {
derivedStateOf { inputText.isNotBlank() }
}
derivedStateOf 内部会缓存上次计算的结果。只有当计算逻辑依赖的状态发生变化,并且计算结果也不等于上次结果时,才会引发下游重组。这属于 Compose 的性能优化手段,在状态频繁变化、界面又不想跟着高频刷新时很实用。
8.3 命名、分层与测试建议
状态管理不只是 API 的问题,更是工程组织的问题。建议从几个维度约定团队规范:
- 命名上,状态用名词,事件用动词。比如
count、username是状态,increment()、onValueChange是事件/回调。这能减少理解成本。 - 分层上,Composable 尽可能是无状态、可复用的展示组件;有状态的部分收敛到页面级的“Route”或“Screen”组件中,再由其组合 ViewModel 和子组件。
- 状态容器上,UI 临时状态留在 Compose 层,业务状态放在 ViewModel,持久化数据放到数据层。不要把所有状态都堆到 ViewModel,也不要让 Compose 直接操作数据库。
借助状态提升,很多纯展示组件可以独立测试:直接传入不同状态,验证它是否正确渲染。把业务逻辑放进 ViewModel 后,也可以在没有 Compose 环境的情况下用单元测试覆盖。这是状态管理带来的工程收益,不只是“代码更漂亮”。
8.4 关于性能的提醒
Compose 的重组是自动的,但“自动”不等于“没有代价”。在列表场景中,如果每个列表项都读取大范围状态,一旦某个字段变化,整个列表都可能重建。合理做法是:
- 把列表项拆成独立的 Composable,传入最小参数;
- 使用
key保证列表项身份稳定; - 对昂贵计算用
remember或derivedStateOf缓存; - 在能够接受的情况下,用
Immutable注解或数据类来帮助 Compose 做参数稳定判断。
这些话题可以继续深入。对现阶段来说,先把状态管理的基础链路跑通,再考虑副作用和性能优化会更稳妥。
9. 总结与后续学习方向
到这里,Compose 状态管理的核心脉络已经梳理完了。你至少应该掌握这几件事:
- 状态是 UI 的输入,重组是状态变化后 UI 的自动更新;
remember保存组合内临时状态,rememberSaveable额外处理配置变更和进程重建;- 状态提升让组件变得更可复用,单向数据流让状态变化路径清晰;
- ViewModel + StateFlow 是页面级业务状态管理的常用组合;
collectAsStateWithLifecycle比collectAsState更适合在真实应用中使用。
这个阶段最容易犯的错误,是把状态管理当成一个“API 查表题”。比如只说“数据变了要用 mutableStateOf”,而不理解为什么。其实 Compose 文档已经把核心思想写得很清楚:State 是值随时间变化的容器,UI 只是对它的描述。理解了这一点,再看各个 API 的设计就顺理成章。
下一步值得继续深入的方向包括:rememberCoroutineScope 处理协程任务、produceState 做异步数据订阅、Hilt 注入 ViewModel、DataStore 做持久化、以及 Compose 的性能优化。这些内容都是在今天这套基础上展开的。
如果你正在用 Compose 开发真实项目,建议先把文中第 5 章和第 6 章的示例放到自己的工程里跑一遍,再用 Layout Inspector 观察重组的边界。建议收藏本文,写作时面对状态混乱的情况,可以按第 7 章的表格快速定位问题。
