很多从传统 View 体系转到 Jetpack Compose 的开发者,布局和控件部分往往上手很快,真正容易被卡住的往往是状态管理。为什么点击了一个按钮,界面没有变化?为什么状态放在 Activity 里能用,换到 Composable 里就丢了?为什么官方文档里的 remember 看起来很简单,到了真实业务中却不知道放在哪一层?本文作为 Compose 声明式 UI 学习系列的第 6 篇,专门把状态管理拆开讲清楚,覆盖核心概念、常用 API 原理、完整代码示例以及常见问题排查,希望能帮你把这块硬骨头啃下来。
1. 背景与核心概念
1.1 声明式 UI 与命令式 UI 的差别
在 Jetpack Compose 之前,Android 开发最熟悉的是 View 体系。这种模式可以称为“命令式 UI”:我们先创建控件,再通过代码主动修改控件的属性,让界面和数据保持同步。
比如更新一个计数器文本,传统写法大概是这样的:
kotlin复制// 传统 View 体系写法:手动同步数据与 UI
var count = 0
val textView = findViewById<TextView>(R.id.tv_count)
button.setOnClickListener {
count++
textView.text = "当前计数:$count"
}
这段代码的问题在于,UI 的状态分散在 Activity、Fragment、Adapter 等多个地方。如果某个页面有多个控件需要同步更新,开发人员就必须在每次数据变化时,手动找到对应的 View,再逐个更新。业务越复杂,这种手动同步的代码就越难维护。
Compose 采用的是“声明式 UI”思路。你只需要描述“这个页面在某个状态长什么样”,不需要关心具体怎么更新控件。当状态变化时,Compose 会自动重跑相关代码,把新状态映射到界面上。
同一个计数器,用 Compose 写是这样的:
kotlin复制@Composable
fun CounterScreen() {
var count by remember { mutableStateOf(0) }
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(text = "当前计数:$count")
Button(onClick = { count++ }) {
Text(text = "点击加 1")
}
}
}
可以看到,没有 findViewById,没有 setText。count 发生变化后,依赖它的 Text 会被自动更新。这就是声明式 UI 的核心体验。
1.2 状态是什么,为什么需要管理
可以先给“状态”一个通俗定义:状态是“会变化、并且驱动界面变化的数据”。
在 Compose 里,@Composable 函数并不是只执行一次。当状态变化时,Compose 可能会重新执行某个 Composable 函数,这个过程叫重组(Recomposition)。如果我们在函数内部写一个普通变量:
kotlin复制@Composable
fun BadCounter() {
var count = 0
Button(onClick = { count++ }) {
Text("当前计数:$count")
}
}
这个 count++ 是有效的,但每次重组时 count 都会被重置为 0,因为局部变量的生命周期只属于当前这次函数执行。按钮点击后虽然变量变了,但 Compose 根本没有感知到这个变化,界面也不会刷新。
所以状态管理的本质是两件事:
- 让 Compose 能“感知”状态的变化。
- 把状态放在正确的生命周期范围内,让它在需要时存在、不需要时释放。
只有理解了这两点,后面看 remember、rememberSaveable、ViewModel 这些方案时,才不会觉得它们只是“几种写状态的语法”。
1.3 状态管理在 Android 开发中的应用场景
状态管理并不是只有一个“计数器”模板。在真实业务中,几乎每个页面都需要处理状态:
- 表单页:输入框内容、校验错误提示、提交按钮是否可用。
- 列表页:加载中、加载失败、空数据、下拉刷新、分页加载状态。
- 购物车:商品数量增减、勾选状态、总价计算、结算事件。
- 多媒体播放器:播放/暂停状态、进度条位置、播放列表当前项。
- 登录模块:账号输入、密码可见切换、登录请求 loading、登录失败提示。
这些场景都可以用同一套状态管理思想来处理:先拆分出状态,再把状态放到合适的层面,最后通过单向数据流驱动 UI 变化。接下来我们从最基础的 API 看起。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 环境准备与版本说明
2.1 开发环境要求
本文中的示例基于 Android 开发环境,需要准备以下工具:
- Android Studio 稳定版。
- JDK 17 或你本机项目实际使用的版本。
- 一个已经支持 Jetpack Compose 的 Android 项目。
如果你还在纠结“Android Studio 怎么设置中文”,这里补充一句:IDE 的界面语言可以安装中文语言包改成中文,也可以保持英文,对实际开发没有影响。更关键的是确保项目的 Kotlin 版本、Android Gradle Plugin 版本和 Compose 编译器版本能配合工作。
由于 Compose 相关工具链更新比较频繁,本文不把版本号写死。你在创建新项目时,Android Studio 会生成一套当前可用的版本组合。如果是从旧项目升级,重点检查 Kotlin 和 Compose 插件版本。
2.2 在项目中引入 Compose 依赖
推荐的 Compose 版本管理方式是使用 Compose BOM(Bill of Materials),也就是用一个总版本控制所有 Compose 库版本,避免库之间版本不匹配。
模块的 build.gradle.kts 大致结构如下:
kotlin复制plugins {
id("com.android.application")
id("org.jetbrains.kotlin.android")
// 如果使用 Kotlin 2.0 及以上,还需要声明 Compose Compiler 插件
id("org.jetbrains.kotlin.plugin.compose")
}
android {
namespace = "com.example.composestate"
compileSdk = 34
defaultConfig {
applicationId = "com.example.composestate"
minSdk = 24
targetSdk = 34
versionCode = 1
versionName = "1.0"
}
buildFeatures {
compose = true
}
}
dependencies {
val composeBom = platform("androidx.compose:compose-bom:2024.06.00")
implementation(composeBom)
androidTestImplementation(composeBom)
implementation("androidx.core:core-ktx:1.13.1")
implementation("androidx.activity:activity-compose:1.9.1")
implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.4")
implementation("androidx.lifecycle:lifecycle-runtime-compose:2.8.4")
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.4")
implementation("androidx.compose.ui:ui")
implementation("androidx.compose.ui:ui-graphics")
implementation("androidx.compose.ui:ui-tooling-preview")
implementation("androidx.compose.material3:material3")
implementation("androidx.compose.material:material-icons-core")
}
注意:上面代码里的版本号只是示例。实际开发时,要么直接使用 Android Studio 新建项目时生成的最新版本,要么去查看官方版本说明,不要为了对齐某篇文章而死板地使用某个旧版本。
还有一个容易踩的坑:Kotlin 2.0 之前,Compose 编译器版本必须和 Kotlin 版本绑定,对应关系需要写在 composeOptions 中。Kotlin 2.0 之后,官方提供了独立的 Compose Compiler Gradle 插件,生成方式更简单。遇到编译错误时,优先检查插件配置,而不是急着改代码。
3. 核心原理拆解:状态与重组
3.1 mutableStateOf 与 by 委托
Compose 最基础的状态 API 是 mutableStateOf。它返回一个 MutableState<T> 对象,这个对象就像一个“状态盒子”,内部保存数据,同时具备通知 Compose 数据变化的能力。
常见的写法有两种:
kotlin复制// 写法一:直接操作 State 对象
val countState = remember { mutableStateOf(0) }
Button(onClick = { countState.value++ }) {
Text("当前计数:${countState.value}")
}
// 写法二:使用 by 委托,直接操作 value
var count by remember { mutableStateOf(0) }
Button(onClick = { count++ }) {
Text("当前计数:$count")
}
两种写法本质一样。by 委托语法让代码更简洁,但需要确保导入 androidx.compose.runtime.getValue 和 setValue。在 Android Studio 中,只要写了 import androidx.compose.runtime.*,就可以直接使用这种委托写法。
这里有一个很容易让新手误解的点:by remember { mutableStateOf(0) } 并不是在定义一个“变量”,而是在为这个状态盒子绑定一个访问属性。每次读取 count,实际上是在读 State 的 value;每次写入 count++,实际上是在调 MutableState 的 setter。因此,count 变化时 Compose 才能知道。
3.2 remember:把状态记住
remember 的作用是把计算结果缓存到组合(Composition)中。所谓组合,可以粗略理解成 Compose 在内存中维护的一套界面结构树。只要这个 Composable 没有从组合中移除,remember 就能让状态一直存在;一旦这个 Composable 离开组合,缓存就被丢弃。
一个常见误区是以为 remember 能像磁盘存储一样保存数据。其实它只是“内存级缓存”,适合保存界面状态,比如输入框内容、弹窗是否显示、当前选中的 tab。它不适合保存需要持久化的业务数据。
remember 还支持传入 key 参数。当 key 变化时,原缓存会被丢弃并重新计算:
kotlin复制@Composable
fun UserCard(userId: String) {
val userDetail = remember(userId) {
// 模拟从仓库加载用户信息
loadUser(userId)
}
Text(userDetail.name)
}
当 userId 改变时,Compose 会认为缓存失效,重新执行 loadUser(userId)。这适合做“根据入参重新构建缓存”的场景。
3.3 rememberSaveable:应对重建
模拟器上旋转屏幕,或者系统因为内存不足回收 Activity,都可能导致 Activity 重建。此时组合会被销毁,remember 保存的状态也会丢失,页面会回到初始值。
rememberSaveable 可以解决这个问题。它会借用 Bundle 机制,把状态保存下来,Activity 重建后自动恢复。用法和 remember 几乎一致:
kotlin复制@Composable
fun CounterScreen() {
var count by rememberSaveable { mutableStateOf(0) }
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text("当前计数:$count")
Button(onClick = { count++ }) {
Text("点击加 1")
}
}
}
需要说明的是,rememberSaveable 能保存的默认类型有限。如果你的状态是自定义对象,需要给它写 Saver,或者在保存前手动拆成 Bundle 支持的类型。数据比较复杂时,建议交给 ViewModel 和持久化存储处理。
3.4 重组:状态读取范围决定刷新范围
Compose 并不是每次状态变化都把整个界面重新绘制一遍,它只会重组那些读取了该状态的可组合函数。这是理解性能问题的关键。
举个例子:
kotlin复制@Composable
fun Parent() {
var count by remember { mutableStateOf(0) }
Column {
ExpensiveHeader()
Text("当前计数:$count")
Button(onClick = { count++ }) {
Text("点击")
}
}
}
这里读取了 count 的范围是 Parent 内部,count 变化时 Parent 会重组,ExpensiveHeader() 和按钮也会被重新调用。如果 ExpensiveHeader 内部做了大量计算,这个页面就会显得卡顿。
常见优化思路是缩小读取范围,把读取状态的 UI 拆成更小的 Composable:
kotlin复制@Composable
fun Parent() {
var count by remember { mutableStateOf(0) }
Column {
ExpensiveHeader()
CountText(count)
Button(onClick = { count++ }) {
Text("点击")
}
}
}
@Composable
fun CountText(count: Int) {
Text("当前计数:$count")
}
这样,count 变化时只有 CountText 内部发生重组,ExpensiveHeader 不会被再次执行。在真实项目中,我们经常利用这种特性来减少不必要的重组。
3.5 状态提升:无状态组件怎么设计
如果每个 Composable 都自己创建状态,状态就会散落各处,父组件很难控制子组件的数据。为了可维护性,Compose 建议使用“状态提升”(State Hoisting)。简单说,就是把状态上移到调用方,让子组件变成无状态组件。
无状态组件的优点是可以复用、容易测试。下面是一个无状态计数器:
kotlin复制@Composable
fun StatelessCounter(
count: Int,
onIncrement: () -> Unit
) {
Column {
Text("当前计数:$count")
Button(onClick = onIncrement) {
Text("点击加 1")
}
}
}
父组件持有状态,并通过参数和回调把数据传给子组件:
kotlin复制@Composable
fun CounterScreen() {
var count by rememberSaveable { mutableStateOf(0) }
StatelessCounter(
count = count,
onIncrement = { count++ }
)
}
这就是典型的“单向数据流”:数据向下传递,事件向上回调。这套思想会贯穿整个 Compose 状态管理。
4. 完整实战案例:购物车页面
4.1 需求拆解
只讲状态 API 容易飘,我们用一个购物车小案例把前面内容串起来。需求如下:
- 页面展示商品列表。
- 每个商品可以增加数量、减少数量、删除。
- 顶部可以快速添加两个预设商品。
- 底部展示购物车总价。
- 点击结算后弹出提示。
这个案例不需要后端,也能覆盖状态管理的核心知识点。
4.2 商品数据模型
先定义商品数据类。商品在业务中是不可变的对象,数量变化时我们生成新的商品对象替换旧对象,这样更容易追踪状态变化。
kotlin复制package com.example.composestate
data class CartItem(
val name: String,
val price: Int,
val quantity: Int
)
这里的 price 用 Int 表示价格,单位是元。实际项目中如果涉及优惠、折扣、多币种,建议用 BigDecimal 或服务端返回的字符串,避免浮点数精度问题。
4.3 使用 ViewModel 管理购物车状态
购物车状态属于业务状态,应该在 Activity 重建后仍然存活。rememberSaveable 虽然能保存简单数据,但并不适合承载购物车这种复杂业务。更合适的方案是使用 ViewModel,配合 StateFlow 向 UI 暴露状态。
新建 CartViewModel:
kotlin复制package com.example.composestate
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
class CartViewModel : ViewModel() {
// 购物车列表状态
private val _cartItems = MutableStateFlow<List<CartItem>>(emptyList())
val cartItems = _cartItems.asStateFlow()
// 一次性事件:结算提示
private val _checkoutMessage = MutableSharedFlow<String>()
val checkoutMessage = _checkoutMessage.asSharedFlow()
fun addItem(item: CartItem) {
_cartItems.update { currentList ->
val index = currentList.indexOfFirst { it.name == item.name }
if (index >= 0) {
val existing = currentList[index]
val newList = currentList.toMutableList()
newList[index] = existing.copy(quantity = existing.quantity + item.quantity)
newList
} else {
currentList + item
}
}
}
fun increaseItem(item: CartItem) {
addItem(item.copy(quantity = 1))
}
fun decreaseItem(item: CartItem) {
if (item.quantity <= 1) return
_cartItems.update { currentList ->
val index = currentList.indexOfFirst { it.name == item.name }
if (index >= 0) {
val newList = currentList.toMutableList()
newList[index] = item.copy(quantity = item.quantity - 1)
newList
} else {
currentList
}
}
}
fun removeItem(name: String) {
_cartItems.update { currentList ->
currentList.filterNot { it.name == name }
}
}
fun checkout() {
val totalPrice = _cartItems.value.sumOf { it.price * it.quantity }
viewModelScope.launch {
_checkoutMessage.emit("已提交订单,共 $totalPrice 元")
}
}
}
代码中使用了 MutableStateFlow 保存购物车列表,使用 MutableSharedFlow 发送一次性事件。StateFlow 适合保存“当前状态”,比如购物车列表;SharedFlow 适合保存“事件”,比如 toast、snackbar、跳转导航。
为什么不用 mutableStateListOf 直接在 ViewModel 里管理?也可以。但 StateFlow<List<CartItem>> 能暴露不可变类型给 UI,同时方便做数据流转换,在日志、测试和后续业务扩展上优势更明显。这里选择 Flow 方案,更接近实际项目的主流写法。
4.4 编写购物车 UI
UI 层涉及多个 Composable,我们拆成两层:
ShoppingCartScreen:顶层页面,负责收集 ViewModel 状态。CartItemRow:单个商品行,是一个无状态组件。
完整页面代码如下:
kotlin复制package com.example.composestate
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun ShoppingCartScreen(
viewModel: CartViewModel = viewModel()
) {
val cartItems by viewModel.cartItems.collectAsStateWithLifecycle()
val snackbarHostState = remember { SnackbarHostState() }
LaunchedEffect(Unit) {
viewModel.checkoutMessage.collect { message ->
snackbarHostState.showSnackbar(message)
}
}
Scaffold(
snackbarHost = { SnackbarHost(snackbarHostState) }
) { innerPadding ->
Column(
modifier = Modifier
.padding(innerPadding)
.fillMaxSize()
.padding(16.dp)
) {
Text(
text = "购物车",
style = MaterialTheme.typography.headlineMedium
)
Spacer(modifier = Modifier.height(16.dp))
Row {
Button(onClick = {
viewModel.addItem(CartItem("Android 开发实战", 59, 1))
}) {
Text("添加图书")
}
Spacer(modifier = Modifier.width(8.dp))
Button(onClick = {
viewModel.addItem(CartItem("机械键盘", 299, 1))
}) {
Text("添加键盘")
}
}
Spacer(modifier = Modifier.height(16.dp))
if (cartItems.isEmpty()) {
Text("购物车为空,试试点击上面的按钮")
} else {
cartItems.forEach { item ->
CartItemRow(
item = item,
onIncrease = { viewModel.increaseItem(item) },
onDecrease = { viewModel.decreaseItem(item) },
onRemove = { viewModel.removeItem(item.name) }
)
}
Spacer(modifier = Modifier.height(16.dp))
Text(
text = "总价:${cartItems.sumOf { it.price * it.quantity }} 元",
style = MaterialTheme.typography.titleLarge
)
Button(onClick = { viewModel.checkout() }) {
Text("结算")
}
}
}
}
}
@Composable
fun CartItemRow(
item: CartItem,
onIncrease: () -> Unit,
onDecrease: () -> Unit,
onRemove: () -> Unit
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column(modifier = Modifier.weight(1f)) {
Text(
text = item.name,
style = MaterialTheme.typography.titleMedium
)
Text(
text = "单价 ${item.price} 元,数量 ${item.quantity}",
style = MaterialTheme.typography.bodyMedium
)
}
TextButton(onClick = onDecrease) {
Text("-")
}
Text(
text = "${item.quantity}",
modifier = Modifier.padding(horizontal = 8.dp)
)
TextButton(onClick = onIncrease) {
Text("+")
}
TextButton(onClick = onRemove) {
Text("删除")
}
}
}
4.5 运行与验证
在 MainActivity 的 setContent 中调用 ShoppingCartScreen:
kotlin复制package com.example.composestate
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.MaterialTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme {
ShoppingCartScreen()
}
}
}
}
点击“添加图书”,购物车列表会出现一个商品行。点击 + 按钮,数量会增长,总价同步变化。点击 - 按钮,数量会减少,但最低保持为 1。点击“删除”,商品从列表移除。点击“结算”,底部会弹出 Snackbar 提示。
这个案例虽然简单,但已经用到了三个关键能力:
MutableStateFlow保存列表状态。collectAsStateWithLifecycle把 Flow 转成 Compose 可观察状态。MutableSharedFlow处理 Snackbar 这类一次性事件。
如果你运行后没有看到预期效果,优先检查依赖里是否有 lifecycle-runtime-compose,以及是否导入了 collectAsStateWithLifecycle。
5. 进阶:Flow、协程与生命周期
5.1 collectAsState 与 collectAsStateWithLifecycle
在使用 ViewModel 暴露 StateFlow 时,UI 层需要把 Flow 转换成 Compose 状态。最简单的方式是 collectAsState():
kotlin复制val cartItems by viewModel.cartItems.collectAsState()
这个 API 来自 Compose Runtime,使用起来很方便,但它会一直在组合中收集数据,没有考虑页面生命周期。
collectAsStateWithLifecycle() 来自 androidx.lifecycle:lifecycle-runtime-compose,它的特点是只在生命周期处于 STARTED 以上状态时收集数据,页面退到后台时会暂停收集,避免后台做无用的 UI 刷新,对减少资源消耗有帮助。
实际项目推荐优先使用 collectAsStateWithLifecycle()。这也是目前官方文档和各类技术分享中的主流做法。
5.2 SharedFlow 实现一次性事件
UI 状态可以分为两类:
- 普通状态:例如购物车列表、加载中标识。UI 可以根据当前状态渲染,即使重建后重新读取,结果也应该一致。
- 一次性事件:例如“跳转到详情页”“弹出错误提示”。这类事件如果被当作普通状态保存,Activity 重建后可能会重复触发。
在上面的购物车案例中,结算提示就是一次性事件,所以使用 MutableSharedFlow。配合 LaunchedEffect 在入口处收集事件,就能做到只处理一次:
kotlin复制LaunchedEffect(Unit) {
viewModel.checkoutMessage.collect { message ->
snackbarHostState.showSnackbar(message)
}
}
LaunchedEffect(Unit) 只会在首次进入组合时启动协程。如果事件发过来时页面还处于后台,这个设计需要额外考虑是否要缓存最新事件,实践中可以根据业务决定。
5.3 状态持久化:rememberSaveable、DataStore、Room 怎么选
很多新手会混淆“界面状态”和“持久化数据”,这里给一个简单的分层思路:
rememberSaveable:保存临时界面状态,适合短时间 UI 恢复,比如输入框内容、选项卡位置。- ViewModel +
SavedStateHandle:保存进程被杀需要恢复的业务状态,配合SavedStateHandle可以自动进行 Bundle 存储。 - DataStore:保存键值对配置,比如用户偏好、开关设置、主题模式。
- Room 或云端服务:保存真正需要长期落地的业务数据,比如购物车记录、消息列表、订单信息。
这些方案并不是互相替代的关系,而是从“临时状态”到“业务数据”的递进。实际开发中,一个页面可能同时用到好几种方案。
6. 常见问题与排查思路
| 问题现象 | 常见原因 | 解决思路 |
|---|---|---|
| 点击按钮后界面不刷新 | 用普通变量保存数据,Compose 无法感知变化 | 改用 mutableStateOf,并配合 remember 或 rememberSaveable |
| 旋转屏幕后数据丢失 | remember 只是内存缓存,不参与状态恢复 |
临时状态改用 rememberSaveable,业务数据交给 ViewModel |
| 重组频繁,页面卡顿 | 状态读取范围过大,导致大量 Composable 被重复执行 | 缩小状态读取范围,把状态读取下沉到叶子组件 |
| 列表数据变了,UI 没有反应 | 修改了对象内部普通属性,Compose 没有跟踪到这个变化 | 使用不可变数据替换对象,或者使用快照集合 |
viewModel() 无法使用 |
缺少 lifecycle-viewmodel-compose 依赖 |
添加该依赖,并确认版本兼容 |
| Compose 编译报错 | Kotlin 与 Compose 编译器插件版本不匹配 | Kotlin 2.0 使用 org.jetbrains.kotlin.plugin.compose,旧版检查 composeOptions |
下面挑三个最典型的问题展开说明。
第一,点击按钮后界面不刷新。这通常不是代码逻辑问题,而是“状态”没有声明成 Compose 可感知的状态。排查时可以搜索这个变量是用 val / var 直接声明,还是通过 by remember { mutableStateOf(...) } 声明。如果不是后者,Compose 默认不追踪它。
第二,旋转屏幕后数据丢失。remember 不会保存 Activity 重建后的状态,这是很多刚从 View 体系转过来的开发者容易踩的坑。如果你希望界面状态在 Activity 重建后恢复,优先用 rememberSaveable。如果数据来自网络或数据库,通常放在 ViewModel 里,配合 SavedStateHandle 恢复。
第三,列表没有刷新。如果你用 data class Item(var quantity: Int) 保存列表数据,然后在循环里直接修改 item.quantity++,Compose 可能无法感知这个变化。更稳妥的做法是,把商品对象设计成不可变对象,修改数量时用 copy() 生成新对象并放回列表。这样无论列表是 StateFlow 还是 mutableStateListOf,都能正确触发 UI 更新。
7. 最佳实践与工程建议
7.1 状态放哪里:三个层级
在 Compose 中,状态不是随便放的。我的建议是分三层考虑:
- UI 层局部状态:比如弹窗展开、输入框内容、动画播放状态,放在 Composable 内部或
rememberSaveable中,不要提交到 ViewModel。 - 页面级 UI 状态:比如当前页面加载结果、列表数据、选中项,放在 ViewModel 中暴露
StateFlow。 - 全局业务状态:比如登录用户、应用主题、权限结果,使用更上层的数据仓库管理,再通过 ViewModel 转发。
原则很简单:状态的作用域越小越好,谁需要谁拥有。
7.2 单向数据流与状态提升
每个 Composable 应该能比较清晰地看出“数据从哪来”和“事件往哪去”。推荐的做法是:
- 子组件不直接修改全局状态。
- 父组件通过参数传递状态。
- 子组件通过回调接口上报用户操作。
如果你发现某个 Composable 内部状态很多,而且需要和兄弟组件共享,那说明应该把状态提升了。不要为了少写参数,把状态塞进一个全局单例。全局单例会让状态来源变得不可追踪,排查问题时会非常痛苦。
7.3 尽量使用不可变数据
使用 data class 时,给每个字段都用 val,而不是 var。数量变化时用 copy() 创建新对象。这样做有几个好处:
- 可以放心地把数据对象传给任何 Composable,不用担心它被隐式修改。
- 方便 diff 运算,Compose 可以更准确地判断是否需要重组。
- 在并发场景下更安全,避免多个协程同时修改同一个对象。
集合层面,如果列表需要频繁增删,可以在 ViewModel 中使用 StateFlow<List<T>>,通过 update 生成新列表。也可以使用 SnapshotStateList 这类 Compose 快照集合,但要注意不要在业务层过度传播 UI 专属能力。
7.4 关注重组范围,而不是盲目优化
Compose 的性能优化和 View 体系思路不同。不要一上来就给所有 Composable 加 remember,也不要到处用 derivedStateOf,先用默认方式做完功能,再通过日志或布局检查工具观察哪些组件在频繁重组。
经验法则有两个:
- 读取状态的组件体积越小,重组范围越小。
- 如果某个高开销组件总是被无关状态触达重组,就要考虑把状态读取移出该组件。
7.5 不要让 Composable 承担业务逻辑
Composable 函数的职责是描述界面。网络请求、数据库读写、复杂计算和状态提交,应该放在 ViewModel、Repository 或者普通工具类中。Composable 里可以调 LaunchedEffect 去触发业务,但不应该把大量业务代码写在里面。这样做的最大好处是方便测试和复用。
7.6 列表数据要给稳定 key
在 LazyColumn 中使用列表时,尽量传入稳定的 key。比如购物车商品可以用 name 作为 key:
kotlin复制LazyColumn {
items(cartItems, key = { it.name }) { item ->
CartItemRow(...)
}
}
稳定 key 可以帮助 Compose 在列表增删时正确复用组件,避免出现状态错位的问题。如果你的商品有服务端 ID,优先使用服务端 ID。
8. 总结与学习路线
这一篇从声明式 UI 的基本概念开始,讲到了 Compose 状态管理的核心对象 State、remember、rememberSaveable,再到状态提升和重组机制,最后用购物车案例串起 ViewModel、StateFlow、SharedFlow 的真实用法。读完你应该能回答这几个问题:
- 为什么 Compose 需要用状态驱动 UI。
remember和rememberSaveable有什么区别。- 状态提升到底提升了什么。
- 页面级业务状态为什么适合放在 ViewModel 中。
- 一次性事件和普通状态分别适合用什么方式传递。
如果你正在跟着视频或官方教程学习 Compose,建议先把本文中的购物车案例跑起来,然后改成你自己的练习项目,比如 TODO 列表、记账本、播放器。只有亲手改过状态来源和提升位置,才能真正理解重组和单向数据流。
下一步可以继续学习 LazyColumn 与列表状态、navigation-compose 页面跳转参数传递、Room 做持久化、Paging 做分页加载。状态管理是这些进阶内容的基础,先把这个根扎稳,后面会顺畅很多。
