Jetpack Compose 已经不算新话题,但每次在社区里看到有人提问,问题往往不是布局不会写,而是状态管理理不清楚。照着示例写一个计数器,点击一下数字变化,感觉声明式 UI 也没那么玄;可一旦开始做真实页面,旋转屏幕数据没了、输入框内容不更新、列表刷新错乱、一个页面改了数据另一个页面不响应,这些问题很难靠搜索引擎一次解决。
我最初对 Compose 状态管理的认知也是从“一个变量 + 自动刷新”开始的,直到踩过几轮坑才意识到:Compose 里真正复杂的不是记住一个数值,而是搞清楚状态从哪里来、由谁修改、活多久、谁需要感知它的变化。这套东西如果没理顺,remember、ViewModel、StateFlow 这些 API 就只是看上去会用的工具。
这篇文章不打算罗列 API 大全,而是给出一个更适合实际开发的状态管理思路。核心判断是一句话:Compose 状态管理的关键不是怎么保存值,而是给每个状态确定来源、作用域和生命周期;这三件事想清楚,具体用什么 API 只是后续执行问题。
1. 声明式 UI 里,状态不是一个“变量”,而是一条更新链路
1.1 从手动刷新到自动重组,改变的是“谁在更新界面”
在 View 体系里,界面和数据显示是两条线。你需要 findViewById 拿到控件,然后在回调里通过 setText、setVisibility 这类方法手动把数据写进界面。代码写多了容易形成一种惯性:状态散落在控件、Adapter、回调里,只有当某个方法被调用时,界面才发生变化。
Compose 把这套流程整个翻转过来。一个 Composable 函数更像是一种“投影”:输入一组状态,输出一棵界面树。状态变化后,Compose 框架负责找到依赖这个状态的调用范围,重新执行并替换界面。
这种开发方式确实更直观,因为你不用再操心“数据变了该更新哪个控件”,只要保证状态本身是正确的。但代价也随之而来:框架能自动刷新,不代表它知道什么状态对你重要。
如果状态是不可观察的,框架感知不到变化;如果状态实例被错误传递,不同页面读到的不是同一个来源;如果状态生命周期设计不对,重建后就会丢失。
所以,在 Compose 里做状态管理,更像是管理一条链路:谁写入、谁读取、谁在状态变化后响应重组。单独背 API 没有用,你需要理解这条链路是怎么工作的。
1.2 普通变量改完没反应,问题出在“不可观察”
先看一个很经典的失败例子:
kotlin复制@Composable
fun Counter() {
var count = 0
Button(onClick = { count++ }) {
Text("当前: $count")
}
}
这段代码不会刷新。原因是普通变量不具备可观察能力,Compose 不知道 count 变了。
改成这样才会生效:
kotlin复制@Composable
fun Counter() {
var count by remember { mutableStateOf(0) }
Button(onClick = { count++ }) {
Text("当前: $count")
}
}
mutableStateOf 返回的是一个可观察状态容器。读取 count 时,Compose 会把当前调用范围登记为依赖;写入时,框架标记这个范围需要重组。如果你不习惯 by 委托,也可以写成 count.value++ 和 count.value。
这里还有一个容易忽视的点:remember 的作用是让 mutableStateOf 实例在重组之间被保留。如果没有 remember,每次重组都会新建一个状态,等于每次从 0 开始。
所以状态管理的第一层边界很清晰:状态必须“可观察”,并且要放在正确的“保存容器”里。
注意:Compose 不会因为你改了一个普通变量就自动刷新。它追踪的是可观察状态,不是对象的任意字段。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. remember 和 rememberSaveable 只是起点,不是终点
2.1 remember 绑定的不是页面,而是“组合位置”
remember 经常被解释成“缓存”,但这个解释容易让人误以为它像 LruCache 一样与页面或 Activity 绑定。准确一点说,remember 保存的是“当前组合位置上的值”:一个 Composable 进入组合时,它申请一块存储空间;离开组合时,这块空间被回收。
举个例子:
kotlin复制@Composable
fun Parent() {
var show by remember { mutableStateOf(true) }
if (show) {
Counter()
}
Button(onClick = { show = !show }) {
Text(if (show) "隐藏" else "显示")
}
}
Counter() 内部的 remember 状态只在 show 为 true 时存在。切到 false 再切回 true,计数器会变成 0。
很多人会觉得“还是同一个页面呀,数据为什么没了?”原因不是 Compose 记性差,而是组合过程本身就允许状态被丢弃。如果不丢弃,旧页面无限堆积,内存迟早被撑爆。
所以,在决定用 remember 时,先问自己:这个状态在页面被移出组合后,还需要保留吗?如果不需要,remember 是合适的;如果需要,就要换更长的存活机制。
2.2 rememberSaveable:能抵抗配置变更,但只救得了“能打包装进 Bundle 的值”
屏幕旋转、深色模式切换、系统语言变化、Activity 被系统回收再恢复,这些都会导致组合销毁重建。remember 存在组合空间里的值会丢掉。
rememberSaveable 解决的是这类问题:它会额外把值写入 Bundle,让状态在组合重建后恢复到之前的数值。
简单示例:
kotlin复制var keyword by rememberSaveable { mutableStateOf("") }
TextField(
value = keyword,
onValueChange = { keyword = it },
label = { Text("搜索关键字") }
)
输入框文字、开关状态、Tab 选中项、滚动位置这类短生命周期界面状态,用 rememberSaveable 是合理的。
但它有一个硬边界:Bundle 能保存的数据类型有限。自定义对象需要实现 Saver,或者把对象拆成基础类型再保存。
还要提醒:不要把真正的业务状态塞进 Bundle。一个搜索结果列表,如果对象很复杂、包含不适合直接序列化的字段,强行塞进 rememberSaveable 只是让它“表面上是恢复了”,却不解决“这个状态到底归谁管理”的问题。
2.3 状态应该放在“离使用点最近”的合法位置
选状态容器时,一个重要原则是:尽量让状态住在“生命周期最短但仍然有效”的层级。
不是所有状态都值得升级成 ViewModel,也不是所有状态都该压缩在 remember 里。可以根据状态类型做一个初步判断:
| 状态类型 | 常见做法 | 选择原因 |
|---|---|---|
| 输入框文字、开关、折叠、Tab | remember / rememberSaveable | 生命周期短,随组合销毁合理 |
| 单页搜索、加载、错误、结果列表 | ViewModel + StateFlow | 配置变更后需保留,异步逻辑需要可测试 |
| 跨页面共享登录态、主题 | 仓库/状态层 + ViewModel 暴露 | 生命周期和业务边界需要明确 |
| 全局临时缓存 | 谨慎使用单例 | 全局单例会让组合订阅关系难以追踪 |
这张表不是强制规范,但它能作为一个快速筛选框架,在动手写状态前帮你想清楚位置。
3. 当状态需要跨界面共享时,ViewModel 才真正入场
3.1 状态提升:让共同父级成为唯一数据源
看一个常见场景:搜索页由一个输入框和一个结果列表组成。
如果输入框自己在内部维护关键字,列表自己也保存结果,两者之间没有任何关联,界面不工作几乎是必然的。
Compose 给的第一个解法是“状态提升”:把多个子组件都需要的数据,提升到它们共同的父级里,再通过参数传给子组件。
kotlin复制@Composable
fun SearchScreen() {
var keyword by rememberSaveable { mutableStateOf("") }
SearchField(keyword = keyword, onKeywordChange = { keyword = it })
ResultList(keyword = keyword)
}
SearchField 不再持有状态,只把变化通过回调通知父级;ResultList 只接收 keyword。这样整个页面只有一个 keyword 来源,任何一处修改,另一处都能通过父级重组感知到。
这就是声明式 UI 里很核心的概念:单一数据源。
但状态提升也有边界。如果 keyword 变化之后要触发网络请求、处理 loading/error、取消旧请求,逻辑放在 Composable 里会很别扭。因为 Composable 不提供稳定的生命周期,也不适合作为独立测试单元。这时状态提升的下一个层级,就是 ViewModel。
3.2 ViewModel 不是缓存,而是“状态 + 业务逻辑”的所有者
ViewModel 在 Compose 应用中经常被误解成“因为配置变更所以要保留的数据缓存”。其实它的职责更重:它是状态的所有者,也是状态变化规则的执行者。
举一个最基础的结构:
kotlin复制class SearchViewModel : ViewModel() {
private val _uiState = MutableStateFlow(SearchUiState())
val uiState: StateFlow<SearchUiState> = _uiState.asStateFlow()
fun onKeywordChange(keyword: String) {
_uiState.update { it.copy(keyword = keyword) }
}
}
uiState 对外暴露为只读的 StateFlow,外部看不到 MutableStateFlow,也就不能在界面里随意写状态。所有修改只能通过 ViewModel 的方法发生。
在 Composable 里收集:
kotlin复制val viewModel: SearchViewModel = viewModel()
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
collectAsStateWithLifecycle 是比 collectAsState 更贴近生命周期的用法:当界面进入停止状态时,集合被暂停,回到前台后再继续。这样后台不会做无谓的界面更新。
需要注意,这个 API 不是所有项目都默认内置的,它通常来自 lifecycle-runtime-compose 和 lifecycle-viewmodel-compose 这两个库。具体版本要以你项目实际使用的 Lifecycle 和 Compose 版本为准。
ViewModel 的关键价值不是“多了一个类”,而是给状态提供了稳定的生命周期边界:配置变更不会销毁它;Activity 真正 finish 或导航栈项被弹出时才清理。它把“状态的存活时间”从组合作用域提升到了业务作用域。
3.3 用 UiState 聚合状态,别让 ViewModel 变成一堆 Flow 的游乐场
在 ViewModel 里常见的坏味道,是同时维护 keywordFlow、resultsFlow、loadingFlow、errorFlow 好几个 MutableStateFlow。界面要同时订阅多个流,状态一变,重组可能触发多次,而且很难看出当前页面完整状态是什么。
更建议的做法是定义一个页面状态模型:
kotlin复制data class SearchUiState(
val keyword: String = "",
val results: List<SearchResult> = emptyList(),
val isLoading: Boolean = false,
val errorMessage: String? = null
)
ViewModel 只对外暴露一个 StateFlow<SearchUiState>,任何变化都通过 update 生成新状态。
这样做的好处很明显:
- Compose 只订阅一个来源,依赖关系清楚;
- 页面当前展示什么,一眼就能从 UiState 看出来;
- 单元测试可以直接断言 UiState 是否符合预期。
当然它也有代价:如果 UiState 太大、太细,任何小修改都会生成新对象,可能引发比预期更大的重组范围。实践中可以把页面拆成若干区域 UiState,而不是强行用一个全局对象装下所有页面。
但总的方向是对的:让状态更新变成可预测的“旧的 UiState + 用户操作/事件 = 新的 UiState”。
4. 最容易翻车的地方:异步、列表、一次性事件和全局共享
4.1 异步旧请求覆盖新结果:常见且难以排查
真实网络场景里,用户输入关键字不会只触发一次请求。假如输入框每次变化都触发搜索:
- 用户输入了
a,请求 A 发出; - 快速输入
ab,请求 B 发出; - B 先返回,界面显示
ab的结果; - A 后返回,如果它仍然执行“把结果显示到 UiState”的更新,界面会被覆盖成
a的结果。
这种竞态问题是状态管理里最典型的坑,因为它不是语法错误,没有报错,只在特定时序下出现。
解决思路有两个方向:
- 在开启新任务前取消旧任务。
- 在结果返回时校验任务是不是当前最新任务,不是就丢弃。
通常优先用取消:
kotlin复制private var searchJob: Job? = null
fun onKeywordChange(keyword: String) {
_uiState.update { it.copy(keyword = keyword) }
searchJob?.cancel()
if (keyword.isBlank()) {
_uiState.update { it.copy(results = emptyList(), isLoading = false) }
return
}
searchJob = viewModelScope.launch {
_uiState.update { it.copy(isLoading = true) }
val results = repository.search(keyword)
_uiState.update { it.copy(results = results, isLoading = false) }
}
}
上面还只是最基础版本。生产环境还要处理防抖、分页、失败重试。但状态管理的原则不变:异步更新必须让“当前输入”和“当前请求”绑定,不能让迟到数据改写新状态。
注意:只要发现有“上次请求把这次结果覆盖了”,优先排查任务取消逻辑,不要直接往 UI 上堆 flag。
4.2 列表状态:该用不可变列表还是 mutableStateListOf?
列表是状态管理里容易纠结的地方。
一种做法是把列表当作 UiState 的一部分,每次更新通过 copy 生成新 List:
kotlin复制_uiState.update { state ->
state.copy(results = newResults)
}
这种写法最直观,也符合单向数据流,推荐作为默认选择。
另一种做法是使用 mutableStateListOf:
kotlin复制val items = remember { mutableStateListOf<Item>() }
items.add(item)
SnapshotStateList 内部支持可观察的增删改,Compose 能侦测变化并触发读取位置的重组,适合局部列表的快捷操作。
真正决定用哪种,不是性能,而是状态的所有者。如果列表是页面状态的一部分,需要进入 UiState 做统一管理,就选不可变列表 + copy;如果只是一个局部下拉数据源、不需要跨页面共享,用 mutableStateListOf 也很顺手。
还有一个容易被忽略的点:列表项的 key。如果使用 LazyColumn,要保证列表项 key 稳定,否则增删或重排时可能出现动画异常、焦点丢失、输入框状态错乱。这是列表状态里最贴近 UI 的边界问题。
4.3 一次性事件:Snackbar、Toast、导航不该进 UiState
“状态”的特点是:它可读取、可重组、可恢复。但现实中有一类东西并不想被反复读取,也不需要恢复,比如弹一句提示、跳转一个页面。
如果把它们放进 StateFlow<Boolean> 或 UiState 的字段里,会出现两个问题:
- 界面重组时可能重复触发;
- 系统重建后可能再弹一次。
比较常见的处理是用 Channel 或 SharedFlow 发送事件,在界面层做一次性收集。
kotlin复制private val _events = Channel<String>(Channel.BUFFERED)
val events = _events.receiveAsFlow()
kotlin复制LaunchedEffect(Unit) {
viewModel.events.collect { message ->
snackbarHostState.showSnackbar(message)
}
}
核心判断是:不要把所有“要发生的事情”都建模成“当前的某种状态”。一次性事件应该走事件通道,持续性的才做状态。
这一点很多教程不会专门讲,但在真实项目里非常关键,也是最容易把代码写脏的地方。
4.4 全局共享:能用,但要买票进场
登录状态、主题、多页面共享的购物车,很多人的第一反应是写一个 object GlobalData,里面放几个 mutableStateOf。
短期确实能用,但长期会给状态管理埋下问题:
- 全局对象和应用进程同生命周期,很难在真正不需要时清理;
- 组合依赖全局状态时,任何地方写入,所有读取的页面都可能重组;
- 单元测试时很难隔离。
并不是说全局单例绝对不能碰,而是要先确认状态是否真的需要全局可见。更稳妥的结构通常是把数据放在仓库层,由各自作用域的 ViewModel 暴露和订阅;确实全局共享时再单独设计。
项目规模不大时,不要为了“未来可扩展”提前引入复杂架构。状态管理讲究“够用且可控”。
5. 一套可以长期复用的状态落地框架:状态四问
5.1 新状态出现时,先问四个问题
与其记 API 组合,我更建议每个状态出现时都走一遍下面的四个问题:
- 这个状态需要活多久?
- 谁会读取它,谁会修改它?
- 状态变化由谁驱动:用户操作、异步回调,还是系统事件?
- 如果组合销毁或者进程重建,它是否需要恢复?
回答完,基本就能确定层级:
| 答案特征 | 推荐方案 |
|---|---|
| 只在当前 Composable 内临时存在,离开即丢 | remember |
| 需要抵挡配置变更,且内容可放进 Bundle | rememberSaveable |
| 有业务规则、异步逻辑、跨界面共享 | ViewModel + StateFlow |
| 跨页面/导航栈共享 | 导航作用域 ViewModel / SavedStateHandle |
| 全局配置、登录态 | 仓库层 + 相应 ViewModel 暴露,谨慎使用全局单例 |
这套“状态四问”不是一种固定架构,而是一种思考顺序。多数状态错乱,都源于没有按这个顺序想清楚就开始写代码。
5.2 从单页跑通开始,再逐步升级
新手容易走两个极端:一个极端是所有状态都塞进 remember,导致旋转即丢;另一个极端是一上来就把每个状态都安排到 ViewModel + Flow,把简单页面拆得极难读。
我建议的路径是:
- 先按最简单的写法让页面跑通,状态先放 remember;
- 然后旋转屏幕,观察哪些状态丢失了,把必须保留的改用 rememberSaveable;
- 当状态开始承担异步任务、需要被多个页面共享、或者想写单元测试时,再迁到 ViewModel;
- 最后根据项目规模决定要不要引入 Hilt、Navigation 的 SavedStateHandle、完整的单向数据流。
每增加一层复杂度,都应该有一个具体理由。状态管理不是越重越好,而是让变化可控。
5.3 一个可以直接参考的 ViewModel 模板
下面这段代码综合了前面的原则:UiState 聚合、StateFlow 对外只读、统一通过方法修改状态、异步任务取消。
kotlin复制data class SearchUiState(
val keyword: String = "",
val results: List<String> = emptyList(),
val isLoading: Boolean = false,
val error: String? = null
)
class SearchViewModel(
private val repository: SearchRepository
) : ViewModel() {
private val _uiState = MutableStateFlow(SearchUiState())
val uiState: StateFlow<SearchUiState> = _uiState.asStateFlow()
private var searchJob: Job? = null
fun onKeywordChange(keyword: String) {
_uiState.update { it.copy(keyword = keyword) }
if (keyword.isBlank()) {
searchJob?.cancel()
_uiState.update {
it.copy(results = emptyList(), isLoading = false, error = null)
}
return
}
searchJob?.cancel()
searchJob = viewModelScope.launch {
_uiState.update { it.copy(isLoading = true, error = null) }
runCatching { repository.search(keyword) }
.onSuccess { results ->
_uiState.update {
it.copy(results = results, isLoading = false)
}
}
.onFailure { throwable ->
_uiState.update {
it.copy(error = throwable.message ?: "加载失败", isLoading = false)
}
}
}
}
}
在界面里:
kotlin复制val viewModel: SearchViewModel = viewModel()
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
这个模板到这一步仍然没有防抖、没有分页、没有缓存,但它已经具备了一个页面状态管理最核心的结构:状态统一、入口统一、异步任务可控。后面加功能时,不需要推翻它。
6. 状态错乱时,按这条链路排查
6.1 不要上来就改代码,先从现象反向定位
遇到状态问题,最怕直接猜。
建议按这个顺序排查:
- 看现象:是按钮点击后没变化?还是旋转后丢失?还是多个界面不同步?
- 看输入:当前修改的到底是不是页面读取的那个状态实例?是不是把同一个状态传给了多个 Composable?
- 看作用域:remember 放在哪个调用位置?有没有放在 if 分支内部?有没有在列表 item 里创建状态?
- 看生命周期:状态在 Activity 重建后还在不在?ViewModel 是被 Activity 持有还是被 fragment/navigation 持有?
- 看异步:是否存在旧任务覆盖新任务?任务有没有在 ViewModelScope 中被取消?
- 看依赖和版本:collectAsStateWithLifecycle 所用依赖是否添加?Compose 编译器与 Kotlin/Compose 版本是否匹配?
下面这张表可以当速查:
| 现象 | 可能原因 | 验证方向 |
|---|---|---|
| 点击没反应 | 状态不可观察/读取入口不对 | 检查是否用 mutableStateOf,是否有 remember |
| 旋转后状态丢失 | remember 无法跨配置变更 | 改用 rememberSaveable 或 ViewModel |
| 数据更新但页面没变 | UI 读的是另一个状态实例 | 检查传参是否是同一个来源 |
| 旧请求覆盖新结果 | 并发任务未取消或结果未校验 | 检查 searchJob?.cancel() |
| 页面 A 改了,B 不刷新 | 状态没有提升到共同层级 | 检查状态所属作用域 |
| 重组范围过大 | UiState 粒度太粗 / 读取点太靠上 | 考虑拆分区域状态 |
6.2 用日志把“状态链路”完整打出来
日志是排查状态问题最快的手段,尤其是 ViewModel 里的状态链路。
可以在 ViewModel 里临时打一条:
kotlin复制_uiState
.onEach { state -> println("UI_STATE: $state") }
.launchIn(viewModelScope)
或者直接在修改状态的方法入口打日志,确认用户操作有没有进入 ViewModel。
接下来看三点:
- 用户操作是否触发 ViewModel 方法;
- ViewModel 内部是否生成了预期的 UiState;
- Compose 是否收集到了新 UiState。
链路在哪一段断开,问题就在哪一段。这比在 Composable 里加一堆日志更有效。
不过,这种日志只是排查工具,不建议长期写进生产代码;正常项目里应该用单元测试和调试工具替代。
6.3 预防复发的三个习惯
三个长期值得保持的习惯:
- 对外只暴露读状态:ViewModel 里不要直接暴露
MutableStateFlow,统一用StateFlow,修改走方法。 - 界面层只订阅,不创建业务状态:Composable 里不要写网络请求,不要处理复杂的业务状态计算。
- 每次新增状态先走状态四问:不让临时状态轻易升格成全局状态,也不让业务状态被困在 remember 里。
这三条不是架构洁癖,而是为了减少“状态到底在哪改的”这种排查成本。
7. 最后说说边界:不是所有项目都要上完整架构
7.1 按项目规模选方案,别为了架构而架构
- 学习项目、Demo、简单页面:remember + rememberSaveable 足够。硬塞 ViewModel 反而让初学者学不到真正的状态流转。
- 中小型应用:单页用局部 UiState,跨页和异步再上 ViewModel + StateFlow。
- 大型应用、多人协作:可考虑 Navigation 作用域 ViewModel、SavedStateHandle、依赖注入、事件通道等工程化方案。
同时,Compose 和 Lifecycle 的版本经常更新,不同版本 API 可能不同。落地前一定先确认项目里实际引入的依赖版本:
kotlin复制// 示例依赖,具体版本以你项目的实际配置为准
implementation(platform("androidx.compose:compose-bom:xxx"))
implementation("androidx.lifecycle:lifecycle-runtime-compose:xxx")
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:xxx")
注意:示例依赖不能直接抄进项目,版本要结合你的工程配置确认。
7.2 状态管理的价值不是“写法好”,而是让变化可控
回看整篇文章,真正值得记住的不是某个 API,而是一种判断方式。
当界面状态还小时,remember 够了;当状态开始有异步、有共享、有生命周期要求时,用 ViewModel + StateFlow;当状态需要跨页面时,再把作用域往上提。
这不是一条越走越复杂的路,而是一条按实际复杂度逐渐增加控制力的路。
以后写 Compose 页面,遇到任何和状态相关的问题,先不要急着加依赖、换架构。停下来,想清楚这个状态该活多久、谁改、谁看、丢了能不能恢复。答案清楚了,代码自然就稳定了。
对我来说,这就是 Compose 状态管理最有价值的部分:它逼着开发者把每个状态的边界想清楚,而一旦边界清楚了,UI 的稳定性和维护性都会好很多。
