Jetpack Compose 的声明式UI开发里,状态管理不是靠单独一个函数就能解决的,而是一套贯穿界面、组件层级和业务层的数据流动方式。很多安卓开发从传统 View 的 findViewById、setText 切到 Compose 后,最直观的感受就是:界面怎么自己刷新了?状态到底放在 remember 还是 ViewModel?为什么别人写的列表不丢状态,我一旋转屏幕就重置?这篇文章就用状态管理这条主线,从最小示例一直拆到业务层,适合刚开始接触 Compose 的安卓开发,也适合从 View 体系迁移过来、想把思路一次理清楚的人。核心不是背函数名,而是先想明白“界面是状态的投影”这件事。
1. 先理解 Compose 为什么会围着状态转
1.1 声明式UI:界面只是状态的样子
传统 View 系统里,你拿到的是一个控件树,数据变了之后需要手动去更新控件:textView.text = "新值",列表刷新还要通知适配器。界面和状态是被分开维护的,写到后面经常出现“某个按钮改了数据,但另一个文本没同步”的问题。
Compose 的思路完全不同。界面不是一个可以随便改的控件树,而是根据当前状态实时计算出来的结果。可以简单理解成:
code复制界面 = f(状态)
状态是输入,界面是输出。状态一变,Compose 会重新执行对应的 Composable 函数,把新的界面计算出来。你在写 Text(text = count.toString()) 时,不是把 count 设置到某个控件上,而是在声明“这个地方显示 count 当前的值”。count 变了,这块区域自己会重新组合。
这就是 Jetpack Compose 的声明式UI 本质。它让代码更短、更不容易出现界面和逻辑不一致的问题,但也带来一个新要求:你必须明确状态放在哪、怎么改、改完之后如何被界面观察。这才是状态管理的核心。
1.2 状态不是普通变量,它要能触发界面更新
在 Compose 中,普通 Kotlin 变量无法触发界面更新。你写:
kotlin复制var count = 0
Button(onClick = { count++ }) { Text("加一") }
点击按钮后 count 变了,但界面不会重新执行 Text 所在的那段 Composable,因为 Composable 函数只认状态对象,不认普通变量。
需要触发界面的状态,必须使用 Compose 能观察的容器。最基础的两个是:
mutableStateOf():创建一个可观察的状态对象。remember:让这个状态对象在重组后仍然保留。
这两者经常搭配出现。先用 remember 保证状态不丢,再用 mutableStateOf 让状态具备通知界面更新的能力。如果只写 remember { 0 },存的是普通 Int,改多少次都不会触发重组。如果只写 var count by mutableStateOf(0),在 Composable 是局部变量,重组时会被重置。两个一起用才是标准写法。
这里还要区分两件事:
- UI 状态:比如输入框内容、是否展开、当前选中的 Tab,属于界面表现。
- 业务状态:比如用户信息、订单列表、登录状态,来自数据层,需要跨页面共享。
这两类状态的作用域不同,保存位置也不同。后面会分别展开。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 至少先把一个状态跑起来:环境与最小示例
2.1 开发环境:Android Studio、Compose 依赖和最小项目
写 Compose 状态管理,前提是项目能跑起来。建议使用较新的 Android Studio,新建项目时直接选择 Empty Activity。模板里如果已经包含 Compose,通常会在 build.gradle.kts 中看到类似这样的依赖:
kotlin复制dependencies {
implementation(platform("androidx.compose:compose-bom:替换成稳定版本"))
implementation("androidx.compose.ui:ui")
implementation("androidx.compose.material3:material3")
}
版本号不要照抄,以你本地能够正常同步的稳定版本为准。Compose 的 BOM 会把 ui、material3、runtime 等版本统一管理,新手不需要手动指定每个库的版本。
如果后面要使用 collectAsStateWithLifecycle,需要额外添加生命周期相关依赖:
kotlin复制implementation("androidx.lifecycle:lifecycle-runtime-compose:替换成兼容版本")
这个库用于在 Compose 中安全地收集 Flow 状态。无论你是 Windows、macOS 还是 Linux 环境,本地开发和模拟器、真机部署都适用。真机调试时,重点看一下输出日志和界面响应,而不只是依赖模拟器。
2.2 remember + mutableStateOf 的最小计数 Demo
我一般会先让新手做一个计数器,代码越简单越好:
kotlin复制@Composable
fun CounterScreen() {
var count by remember { mutableIntStateOf(0) }
Column(
modifier = Modifier.padding(24.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "当前计数:$count",
style = MaterialTheme.typography.headlineMedium
)
Button(onClick = { count++ }) {
Text("增加")
}
}
}
这里 mutableIntStateOf(0) 创建了一个可观察的 MutableState,by 委托让你可以直接读写 count。点击按钮时 count++ 修改了状态值,Compose 检测到这个状态被 Text 读取过,于是重新执行这段界面。
如果你的 Compose 版本比较老,可以使用 mutableStateOf(0),效果一样。
2.3 用三个动作验证状态是否可观察
只写代码不够,还要会验证。我建议按下面三个动作来确认状态管理是否正常:
- 运行项目,确认初始界面正常显示
当前计数:0。 - 连续点击按钮,观察数字是否每次增加。
- 旋转屏幕,把手机切到横屏再切回来,看数字是否保留。
前两步验证的是“状态能不能驱动界面”,第三步验证“状态能不能跨越配置变化保留”。大多数初学者在前两步没问题,在第三步会发现状态被重置了。原因在于旋转屏幕时 Activity 会重建,整个 Composable 组合过程也会重新开始。这时候 remember 就不够用了,需要用 rememberSaveable 来保存可恢复的状态。
这也是状态管理最容易遇到的第一个分岔路。
3. 本地状态的三种保存方式:remember、rememberSaveable、自定义 Saver
3.1 remember 与重组的关系
remember 做的事情是:在组合期间保存一个值。当 Composable 因为状态变化而重组时,被 remember 包裹的值不会被重新创建。但要注意,只要这个 Composable 从组合树中退出,或者整个 Activity 重建,remember 保存的值就会丢失。
举个例子,一个条件分支:
kotlin复制var showDetail by remember { mutableStateOf(false) }
if (showDetail) {
DetailContent()
}
DetailContent 里的局部 remember 状态,在 showDetail 为 false 时会一起被销毁。下次再进入这个分支,状态是全新的。这不是 Bug,而是作用域设计。状态应该只存在于它被需要的地方。
如果把业务数据也放在这种局部 remember 里,一旦组合层级变化,数据就会不见。所以本地状态和业务状态一定要分开放。
3.2 rememberSaveable 与配置变更
rememberSaveable 是为了处理 Activity 或 Fragment 重建设计的。旋转屏幕、系统资源不足、用户切换深色模式等场景,都会触发配置变更和重建。remember 扛不住这种重建,rememberSaveable 可以把状态保存到 Bundle 中,重建之后尝试恢复。
计数器的写法可以直接换成:
kotlin复制var count by rememberSaveable { mutableIntStateOf(0) }
字符串、Int、Boolean、枚举、Parcelable 等系统能自动存进 Bundle 的类型,都可以直接用 rememberSaveable。
如果输入框里的文字不希望旋转后就清空,优先用:
kotlin复制var inputText by rememberSaveable { mutableStateOf("") }
这里最容易被忽略的是:rememberSaveable 解决的是配置变化和进程重建时的状态恢复,但加载过多、体积过大的数据到 Bundle 里并不合适。大对象、图片缓存、临时列表,不应该往这里塞。它只是 UI 状态恢复,不是数据持久化。
3.3 自定义 Saver 保存复杂对象
当状态是一个 data class,并且每个字段都能放进 Bundle 时,可以自定义 Saver。比如过滤条件:
kotlin复制data class FilterState(
val keyword: String = "",
val sort: String = "default",
val page: Int = 1
)
使用 listSaver 保存会比较直接:
kotlin复制val FilterSaver = listSaver<FilterState, Any>(
save = {
listOf(it.keyword, it.sort, it.page)
},
restore = {
FilterState(
keyword = it[0] as String,
sort = it[1] as String,
page = it[2] as Int
)
}
)
var filter by rememberSaveable(stateSaver = FilterSaver) {
mutableStateOf(FilterState())
}
自定义 Saver 的核心是:save 把你把对象拆成系统可保存的字段,restore 再把字段拼回对象。拆字段时要保持顺序稳定,否则恢复时会错位。
如果对象里包含不可序列化的成员,比如某些第三方模型对象,做法是先转成可保存的字符串或数据类,再通过 Saver 恢复。不要把整个大对象硬塞进 Bundle。
到这里,本地状态的基本保存方式已经清楚了。下一步是处理组件之间的状态传递。
4. 状态跨组件流动:状态提升与单向数据流
4.1 无状态组件:父组件给什么,子组件就显示什么
在 Compose 里,一个 Composable 内部有自己的状态,也可以完全由外部传入状态。后一种更有复用价值。比如一个显示计数和按钮的组件:
kotlin复制@Composable
fun CounterContent(
count: Int,
onChange: (Int) -> Unit
) {
Column(
modifier = Modifier.padding(24.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "当前计数:$count",
style = MaterialTheme.typography.headlineMedium
)
Button(onClick = { onChange(count + 1) }) {
Text("增加")
}
}
}
这个组件内部没有自己的状态。它显示什么由 count 决定,用户操作之后通过 onChange 回调告诉外部发生了什么。这种方式叫无状态组件。
有状态和无状态的区别在于状态所有者。无状态组件容易测试、容易复用,也容易在多个页面间统一表现。它不是把所有状态都放外部,而是把“需要被外部控制的逻辑”提升出去。
4.2 子组件要改父组件状态,状态提升才有意义
如果上级页面需要根据子组件的状态做出联动,比如搜索关键词变了,列表要跟着过滤,那么状态不能只藏在输入框内部。
做法是:
- 在父组件创建并持有状态。
- 把状态值传给子组件。
- 子组件通过回调修改父组件的状态。
实际使用中,状态提升最常见的坑有三个:
- 把状态一层一层从子组件传到了父组件,中间组件不得不多写几个参数,但最后发现状态不应该放那么高。
- 为了“少传几个参数”,把状态放到一个全局单例里,结果页面退出后状态还留在内存里,影响其他页面。
- 回调方法没有做
remember或稳定函数封装,导致组件频繁重组。
提升的原则是:谁需要这个状态,或者谁需要改变这个状态,就把状态放在离它们最近的那个公共父节点。
4.3 不要把全局状态当默认方案
有的新手写状态管理,容易一上来就用 object 单例保存一堆可变字段,然后到处直接读写。这种方式在很小的小工具里能跑,但项目变大后会遇到几个问题:
- 无法知道谁修改了状态,调试困难。
- 状态生命周期和应用进程绑定,退出页面时不会自动清理。
- 多模块引用同一个全局对象,会让模块耦合越来越重。
- 测试时难以重置数据,用例之间互相污染。
全局状态只适合应用级配置这类少数场景,比如主题模式、登录信息。页面级业务状态优先放 ViewModel,跨页面共享也尽量通过 ViewModel 作用域来限制生命周期,而不是放一个永远不死的全局对象。
5. 业务状态的容器:ViewModel + StateFlow
5.1 ViewModel 的作用域和职责
ViewModel 是 Jetpack 架构组件里专门保存界面相关数据的容器。它有三个特点,对 Compose 状态管理很关键:
- 在配置变化时保留数据,比如旋转屏幕后 ViewModel 不会重建。
- 跟随 Activity 或 Fragment 的生命周期自动释放,不会像全局对象那样长期占用内存。
- 天然支持与数据层、仓库层打交道,适合放业务逻辑。
Compose 中使用时,可以把 ViewModel 当作状态容器的入口:
kotlin复制class CounterViewModel : ViewModel() {
private val _uiState = MutableStateFlow(CounterUiState())
val uiState: StateFlow<CounterUiState> = _uiState.asStateFlow()
fun increment() {
_uiState.update { current ->
current.copy(count = current.count + 1)
}
}
}
data class CounterUiState(
val count: Int = 0,
val lastActionTime: Long = 0L
)
这里使用 StateFlow 而不是多个 mutableStateOf,原因在于:
- 状态统一放在一个不可变数据类里,界面只观察一个数据源。
- 修改状态时通过
copy生成新对象,界面可以知道“旧状态”和“新状态”的区别。 - 用
MutableStateFlow内部保存,对外只暴露只读的StateFlow,外部组件无法随意修改状态。
5.2 为什么状态不建议被到处直接改
有些写法会在 ViewModel 里直接暴露 mutableStateOf:
kotlin复制var count by mutableStateOf(0)
private set
小界面下这样写没问题,也更简单。但界面变多、状态字段变多之后,直接暴露可变状态很难追踪变化路径。你无法判断是哪个页面改了 count,也无法简单地加日志、加防抖或者做状态擦除。
更稳妥的方法是:对外暴露只读状态,所有修改都通过 ViewModel 的方法来执行。这样状态变化入口收敛,排查问题时只需要看哪些方法调用修改了状态。
5.3 生命周期安全地收集状态
Compose 中收集 StateFlow 状态,最简单的方式是:
kotlin复制val uiState by viewModel.uiState.collectAsStateWithLifecycle()
collectAsStateWithLifecycle 是官方推荐的方式。它会在界面进入后台时暂停收集,回到前台时恢复,避免不必要的计算和资源浪费。如果只是写学习 Demo,用 collectAsState() 也可以,但做正式项目时建议直接采用前一种,后面不用回头改。
使用时别忘了添加生命周期相关依赖:
kotlin复制implementation("androidx.lifecycle:lifecycle-runtime-compose:替换成兼容版本")
到这里要强调一个边界:ViewModel 适合保存 UI 状态和简单的页面交互逻辑,但复杂业务逻辑不应该堆在 ViewModel 里。网络请求、数据库操作、文件处理等应该放在数据层或仓库层,ViewModel 只做调度和状态转换。
6. 加载状态与异步数据:用 sealed interface 表达三种结果
6.1 不要把所有数据加载逻辑塞进 Composable
Composable 里直接写网络请求是非常不推荐的做法。原因很简单:Composable 会被重组,如果它的调用位置、参数发生变化,函数会重新执行,而网络请求又不想在每次重组时都重新发起。有人会想尽办法加标志位防止重复请求,但组合执行和业务调度混在一起,代码会越来越绕。
正确做法是:把异步加载放到 ViewModel 中,Composable 只根据状态展示结果。
6.2 用 sealed interface 定义状态集合
一个列表页通常会经历加载中、加载成功、加载失败三种状态。用 sealed interface 比用多个布尔值清晰得多:
kotlin复制sealed interface ListUiState {
data object Loading : ListUiState
data class Success(
val items: List<RemoteItem>
) : ListUiState
data class Error(
val message: String
) : ListUiState
}
ViewModel 中维护这个状态:
kotlin复制class ItemListViewModel(
private val repository: ItemRepository
) : ViewModel() {
private val _uiState = MutableStateFlow<ListUiState>(ListUiState.Loading)
val uiState: StateFlow<ListUiState> = _uiState.asStateFlow()
init {
loadItems()
}
fun loadItems() {
viewModelScope.launch {
_uiState.value = ListUiState.Loading
try {
val items = repository.fetchItems()
_uiState.value = ListUiState.Success(items)
} catch (e: Exception) {
_uiState.value = ListUiState.Error(e.message ?: "加载失败")
}
}
}
}
使用 when 在 Composable 中处理状态:
kotlin复制when (val state = uiState) {
is ListUiState.Loading -> LoadingIndicator()
is ListUiState.Success -> ItemList(items = state.items)
is ListUiState.Error -> ErrorMessage(
message = state.message,
onRetry = viewModel::loadItems
)
}
这样的好处是:状态一目了然,不会再出现“既在加载,又有部分数据,还有个错误提示”同时存在的混乱情况。想加空数据状态,就是新增一个 Empty,改动起来很清晰。
6.3 重试、取消和状态副本
实际开发中,只看“三态”还不够。要注意三点:
- 重复加载。进入页面的
init和点击重试按钮都会调用loadItems(),要确保两次调用不会重叠产生竞态。可以使用Job保存当前加载任务,重试前取消上一次。 - 数据刷新。下拉刷新通常需要保留现有列表,而不是直接切到全屏 Loading。这时候可以单独加一个
isRefreshing字段,和页面首次加载分离开。 - 失败后的重试不能只是简单调用一次,还要考虑接口超时、断网、返回空列表等边界情况。日志要能看清状态从 Loading 到 Success 或 Error 的完整路径。
如果业务中还需要分页,可以给状态增加 page、isLoadingMore 等字段,并保证新旧列表拼接时不会重复、不会丢失顺序。
7. 性能与边界:重组频率、derivedStateOf、不可变数据
7.1 什么时候用 derivedStateOf
状态管理里,有些状态是“由其他状态推导出来的”。比如输入框里的关键词和搜索结果,搜索结果是关键词状态经过一定计算后得到的。每次关键词变化都重新计算结果,当然也可以,但如果有多个状态影响同一个结果,或者计算结果很重,就可以用 derivedStateOf 做合并和缓存。
一个典型场景是列表滚动位置:
kotlin复制val listState = rememberLazyListState()
val showTopBar by remember {
derivedStateOf {
listState.firstVisibleItemIndex > 0
}
}
这里 showTopBar 不是独立状态,而是根据滚动位置推导出来的。derivedStateOf 只在源状态变化并最终影响结果时触发重组。没有它,你可能会在每次滚动时手动更新一个普通状态,导致重组范围不必要地扩大。
但 derivedStateOf 不是银弹。如果只是在两个普通状态之间做个简单拼接,直接用:
kotlin复制val greeting = "$firstName $lastName"
这样反而更清晰。derivedStateOf 主要用于“计算结果可能比源状态变化次数更少”的场景。
7.2 控制重组范围,减少大对象直接改
状态管理是否合格,不只看功能是否正确,还要看重组范围是否合理。Compose 的最小重组范围是读取状态的那个 Composable 函数。如果一个页面最外层读取了一个大状态,那么状态里任何一个字段变化,整个大页面都可能重组。
避免这种问题,常见的做法是:
- 状态尽量拆分,不要让不相关的 UI 组件观察同一个大对象。
- 列表项的状态独立处理,不要因为列表容器的状态变化而让所有列表项一起重组。
- 使用
remember把不需要跟状态绑定的计算结果缓存起来。 - 对稳定的回调做包装,避免每次重组都创建新的 Lambda 导致子组件也跟着重组。
比如把页面状态拆成 TopBarUiState 和 ContentUiState,比一个大 State 放在顶层更利于局部更新。不过也要看实际情况,状态拆太碎,代码可读性也会下降,需要平衡。
7.3 组合不是业务层:逻辑应该放哪
很多人刚开始写 Compose,容易把逻辑直接写进 Composable:
kotlin复制@Composable
fun LoginScreen() {
var phone by remember { mutableStateOf("") }
fun checkInput(): Boolean {
return phone.length == 11
}
}
这种写法能跑,但函数内部嵌套函数会让代码难以复用。真正稳定的是把输入校验、表单提交、网络请求调度都放到 ViewModel 或普通工具层中,Composable 只负责展示状态和分发事件。
一个稳妥的分层参考:
- Composable:接收状态,显示界面,把用户操作转成事件。
- ViewModel:保存 UI 状态,处理页面内交互,调用数据层方法。
- Repository / DataSource:负责网络、数据库、文件等数据来源。
这样做之后,大多数“组合里改数据但界面不刷新”的坑都不会遇到,因为你已经明确了状态所有者。
8. 常见问题排查:先看日志,再改参数
8.1 几个高频问题
状态管理出问题时,现象往往很接近,但原因完全不同。先列几个最常见的:
界面没刷新
检查读取状态的方式。状态是被 remember { mutableStateOf(...) } 保存的,还是普通变量?状态是否被 by 委托正确读取?文本里有没有把状态值传给其他 Composable 后被拦截?
旋转屏幕后状态丢失
用 remember 的状态会丢,改成 rememberSaveable。自定义对象或列表需要检查 Saver 是否配置。如果状态原本就在 ViewModel 里丢失了,那就要看 ViewModel 是否真的存在、有没有跟着 Activity 重建。
重组过于频繁
先看日志里 Composable 的调用次数。如果每次输入一个字符,整个页面都重组,说明状态作用域太大。把小范围状态往下沉,大对象状态拆开。避免在组合中直接创建不稳定的 Lambda,必要时用 remember 包裹回调。
列表项状态错乱
列表复用时,如果每项都靠位置索引保存状态,滚动后可能串项。使用稳定 ID 作为 key,让 Compose 正确识别每一项。状态尽量放在 Item 内部,或者以 ID 为键的 Map 中。
8.2 排查顺序
遇到状态管理问题,我建议按这个顺序排查:
- 先看现象。是状态没更新,还是界面没跟着刷新,还是刷新了一部分但不对。
- 再看日志。有没有异常堆栈,有没有网络错误,有没有重组警告。
- 再看输入。输入数据是否真的是新值,普通变量和 Compose 状态是否混用。
- 再看生命周期。组件是否被销毁重建,状态是否被放在错误作用域。
- 最后才是改参数。把
remember改rememberSaveable,把状态上提或下沉,把业务逻辑移进 ViewModel。
很多问题不是 Compose 本身实现错了,而是状态放错了位置,或者观察的对象没有被 Compose 正确识别。先定位状态所有者,再改代码,比盲目调参数有效得多。
最后说一点个人感受:状态管理没有万能模板。计数器用 rememberSaveable 就够了,页面级业务用 ViewModel,跨模块共享再考虑更重的方案。真正落地时,最该盯住的是状态的作用域、状态的可观察性、以及状态变化时重组范围有多大。把这三点顺一遍,Compose 的状态管理基本就不会跑偏。
