07.1.1.7.1 组合、重组与状态
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.7 Jetpack Compose 深入
本节要解决的问题
本节围绕「组件如何被组合、状态变化后哪些节点会重组、状态值由谁持有与保存」展开:从可组合项在组合树中的位置与分组,到重组触发条件与跳过判定,再到 remember 系列、快照状态、状态提升、CompositionLocal 与副作用选型。版本基线:Compose BOM 2024.x、Kotlin 2.x、Android 14 / compileSdk 34;版本敏感行为标「待确认」并写明验证点。
07.1.1.7.1-001 什么是 @Composable 可组合函数,它和普通 Kotlin 函数有何本质区别?
一句话结论
@Composable 是被 Compose 编译器改写的函数:它不直接 new 视图对象,而是在当前 Composition 中记录一段可复用的描述,编译器据此生成节点创建、更新与跳过的代码。
概念解释
普通函数调用一次得到一次返回值;可组合函数可以被多次调用,每次调用在组合树中对应一个位置(group),函数体被编译器改写为带状态记录与变更检测的执行单元,而不是传统面向对象意义上的组件实例。
原理流程
编译器扫描 @Composable 函数
→ 在调用点插入组表记录(group / node 边界)
→ 运行时首次组合:按顺序执行函数体,创建节点树
→ 后续重组:按组表定位节点,决定重调、跳过或离开
代码或图示
@Composable
fun Greeting(name: String) {
Text("Hello $name")
}
常见误区
- 以为 @Composable 等价于「返回一个 View 的工厂函数」,实际它产出的是组合描述与节点引用。
- 以为可组合函数每次调用都会新建一套 UI 对象,首次组合之外多数调用只是更新既有节点。
追问
- @Composable 函数可以被普通非组合函数调用吗?答:不能直接调用,必须由组合入口(setContent、其他可组合项)驱动;编译器会拒绝非组合上下文直接调用。
- 可组合函数必须无参吗?答:参数可以有,但参数类型要参与稳定性判定(见稳定性相关题目)。
07.1.1.7.1-002 可组合函数为什么必须是幂等的?
一句话结论
同一个输入应当产出同样的界面描述;函数体不能依赖外部可变全局状态或调用副作用,否则重组重放时结果不确定。
概念解释
重组可能在任意帧被调度,同一函数可能被执行一次、两次或被跳过。幂等要求意味着:相同参数下多次执行得到相同结果,外部副作用(写库、发请求)必须放进 Effect,而不是直接写在函数体里。
原理流程
相同参数 + 相同状态
→ 首次组合输出 A
→ 重放 / 重组仍输出 A
→ 副作用只在 Effect 中按 key 精确执行一次
代码或图示
// 反例:函数体里直接发请求,重组时会重复触发
@Composable
fun Bad() {
viewModel.load() // 应放入 LaunchedEffect
}
常见误区
- 把「幂等」理解成函数不能读状态,实际读取只读状态是允许的,禁止的是函数体产生写副作用。
- 认为幂等只在单元测试里重要,运行时重组重放同样要求可重复执行。
追问
- 不幂等会观察到什么现象?答:界面抖动、请求重复发出、计数器在重组时被再次累加。
- 哪些代码必须移出组合主体?答:网络请求、数据库写入、订阅注册、计数器自增,统一交给 LaunchedEffect / DisposableEffect。
07.1.1.7.1-003 可组合项在组合树中如何被创建和离开(enter / leave group)?
一句话结论
首次组合时每个调用点进入对应的 group;当条件分支、列表项或导航使该调用点不再被执行时,对应 group 被标记离开并回收其状态与节点。
概念解释
组合树由一组嵌套 group 构成,group 与调用位置一一对应。进入组合创建节点并关联 remember 状态;离开组合时 onDispose 回调触发,remember 缓存与订阅被释放。配置变更重建界面时节点树可保留,真正离开 Composition 才会销毁。
原理流程
进入组合 → 创建 group、分配节点、挂载 remember 状态
→ 重组期间仍被调用 → 保留 group
→ 调用点消失(if 为 false / 列表移除 / 退出导航)→ group 离开
→ 触发 DisposableEffect.onDispose,回收状态与订阅
代码或图示
if (showDetail) {
DetailCard() // showDetail 翻转为 false 时该 group 离开组合
}
常见误区
- 把「Activity 旋转重建界面」当成 group 离开,配置变更保留的状态走 rememberSaveable,不是销毁。
- 以为离开组合后节点对象立刻被 GC,实际回收还受节点树与引用关系影响。
追问
- 如何确认一个 group 已经离开?答:观察 DisposableEffect 的 onDispose 是否回调、remember 状态是否被清除,也可在 Layout Inspector 中查看节点树。
- 列表项离开组合对应什么回收路径?答:懒布局按可见性回收组合,离屏项的 group 进入可复用状态(懒布局复用机制另见布局篇)。
07.1.1.7.1-004 同一个可组合函数在不同位置被调用,实例状态为什么互不干扰?
一句话结论
状态关联的是组合树中的位置(group),而不是函数名;两个调用点处于不同 group,各自持有独立的 remember 状态与节点。
概念解释
函数本身是共享的代码单元,remember 缓存挂在调用点所属的 group 上。因此同一函数在页面顶部和底部各调用一次,两个计数器互不影响;把它们放进不同分支时,分支切换也按位置保留各自状态。
原理流程
调用点 A → group A 持有 remember A
→ 调用点 B → group B 持有 remember B
→ 状态读取与写入各自归位,重组互不连带
代码或图示
Counter() // group A
Counter() // group B,两份独立计数
常见误区
- 以为可组合函数像单例对象,全局只有一份内部状态。
- 在同一 group 内重复调用同一函数并期待共享状态,实际仍按调用位置区分。
追问
- 什么情况下两处调用会共享状态?答:状态被提升到共同祖先、或通过 CompositionLocal 向下注入,才形成共享;函数内部 remember 默认不共享。
- 位置对应的依据是什么?答:编译器按调用顺序与分支结构分配组表索引,因此同一分支内调用顺序必须稳定(见条件分支题目)。
07.1.1.7.1-005 条件分支中调用可组合项时,顺序与位置为什么重要?
一句话结论
组合树按调用顺序对位匹配,分支内增删调用或调换顺序会改变 group 索引,导致状态错配;需要稳定的位置就用 key 锚定。
概念解释
重组时新的调用序列与旧组表按顺序对齐。如果 if/else 两个分支里调用的组件数量、顺序不同,编译器与运行时按位置配对,可能把 A 分支的状态挂到 B 分支的节点上。列表与条件场景可用 key 参数显式标识身份,避免位置漂移。
原理流程
旧序列: [A, B, C]
新序列: [A, C, B] → 按位置配对,B/C 状态可能错位
显式 key: A(a) B(b) C(c) → 按身份匹配,重排不丢状态
代码或图示
Column {
items(list, key = { it.id }) { item ->
RowItem(item)
}
}
常见误区
- 随意在分支前后插入新组件后,期待原有组件状态原样保留。
- 列表不用稳定 key,删除中间项后状态、滚动位置错挂到相邻项。
追问
- key 应该取什么值?答:业务上稳定唯一的标识(如数据 id),不要用列表索引,索引会随增删漂移。
- 分支内组件数量不一致会怎样?答:多余的 group 离开组合,缺失的 group 重新进入,状态随之销毁重建。
07.1.1.7.1-006 可组合项可以有返回值吗,返回值如何参与组合?
一句话结论
可以返回普通值(如 Int、State),返回值在当前调用上下文参与计算;可组合项本身不是通过返回值把 View 交给外层。
概念解释
部分可组合项返回测量结果、布局坐标或派生状态,例如 remember 工厂返回缓存值;但界面结构通过节点树表达,外层拿到返回值后继续参与组合流程。返回值类型不改变该函数可组合的性质。
原理流程
@Composable fun measure(): Int
→ 组合执行时算出返回值
→ 外层把返回值用于条件、尺寸或状态派生
→ 节点树仍由函数内部的可组合调用构建
代码或图示
val count = remember { mutableStateOf(0) }
val label = count.value // 读取状态并参与本次组合
常见误区
- 以为可组合项只能返回 Unit,把需要派生值的逻辑强行抽到非组合函数。
- 通过返回 View 对象给旧体系使用,应走互操作桥接(见互操作篇)。
追问
- 返回值变化会触发重组吗?答:返回值本身不是状态;它依赖的 State 被读取时才订阅重组,返回值在重组时重新计算。
- 可组合函数返回 State 与普通数据有何区别?答:State 是可观察快照对象,后续读取它的节点会订阅;普通返回值只是一次计算结果。
07.1.1.7.1-007 可组合项参数有哪些类型约束,为什么不能传任意类型?
一句话结论
参数类型必须参与 Compose 的稳定性判定:原始类型、不可变类型稳定;可变类、集合包装、lambda 闭包等可能不稳定,影响跳过重组。
概念解释
编译器为每个可组合项推导参数是否稳定(stable/immutable),稳定参数未变时该节点可被跳过。参数类型可以是任意 Kotlin 类型,但不稳定类型意味着编译器无法证明相等,保守地不跳过。
原理流程
参数类型 → 编译器稳定性推导
→ 稳定:equals 未变即可跳过
→ 不稳定:每次重组都视为可能变化,保守重调
代码或图示
@Composable
fun ProfileCard(user: User, onEdit: () -> Unit) { /* ... */ }
常见误区
- 以为参数是 class 就天然稳定,class 内部可变字段会让它变成不稳定类型。
- 把
List<Item>当作不可变,Kotlin 只读集合在 Compose 视角默认仍可能被修改。
追问
- 不稳定类型如何转为稳定?答:标注
@Immutable或@Stable、使用不可变包装(immutable collection)、把字段改为不可变,或在边界处做快照拷贝。 - 基本类型为什么稳定?答:值语义且不可变,equals 比较可证明未变化。
07.1.1.7.1-008 Composable 的调用上下文(Composition)承载了什么信息?
一句话结论
Composition 是一次组合的运行上下文:保存组表、remember 缓存、状态订阅、CompositionLocal 读取记录与节点树,并在重组时定位到对应 group。
概念解释
每个 setContent 入口对应一个 Composition。上下文里记录当前执行位置、已注册状态订阅、局部值提供者以及节点创建结果。重组不是从头重跑,而是在既有 Composition 上下文中按组表增量更新。
原理流程
setContent 入口 → 创建 Composition
→ 执行可组合调用序列,记录 group / remember / 订阅
→ 状态变更 → 上下文按订阅定位受影响 group
→ 增量重组并回写节点树
代码或图示
setContent {
Theme { AppRoot() } // 该作用域对应一个 Composition
}
常见误区
- 以为 Composition 等价于 Activity 实例,它随宿主生命周期建立与释放,配置变更时可保留。
- 以为多个屏幕共用一个 Composition,导航切换本质是同一棵树内的 group 增删。
追问
- Composition 何时被释放?答:宿主(Activity/View)分离、CompositionController 释放时;释放后所有 remember 状态与订阅一并回收。
- CompositionLocal 记录存在哪里?答:存在当前上下文的局部值表中,按层级向下查找。
07.1.1.7.1-009 什么是分组(group),组合记录(Compose Node tree)如何保存状态?
一句话结论
group 是组合树中与调用点对应的记录单元,保存节点引用、remember 槽位、状态订阅与局部信息;重组通过 group 索引对位更新。
概念解释
编译器把可组合调用序列翻译成组表,每个嵌套边界形成 group。节点树(layout/draw 节点)挂在 group 之下,remember 值存放在 group 的槽位中。状态订阅同样记录在 group 上,离开组合时随 group 释放。
原理流程
group
├─ 节点引用(layout / draw / component node)
├─ remember 槽位序列
├─ 状态订阅记录
└─ 子 group 列表
代码或图示
Root group
├─ Text group(remember 槽位 0)
└─ Column group
├─ Row group
└─ Row group
常见误区
- 把 remember 状态存在函数对象上,实际槽位属于 group 而非函数实例。
- 以为节点树就是 Kotlin 对象树逐层 new 出来,节点由组合记录驱动创建与复用。
追问
- 组表索引如何保证稳定?答:调用顺序、分支结构稳定时索引对位;结构变化时按 key 或新顺序重建对应 group。
- 节点与 group 的关系?答:一个 group 可以承载一个或多个布局/绘制节点,节点复用取决于组件与布局结构。
07.1.1.7.1-010 可组合项能否在循环或 if 中调用,状态索引如何对应?
一句话结论
可以在循环、if、when 中调用;remember 槽位按该 group 内的调用顺序分配,循环项状态按迭代位置或 key 对应。
概念解释
循环内调用组件在同一 group 内形成子序列,每个迭代对应一个位置。普通列表依赖顺序对位;增删项时需要业务 key 锚定身份,否则状态随索引漂移。if 分支只在条件为真时进入对应 group。
原理流程
for (item in items) {
RowItem(item) // 每次迭代一个子位置
}
key = item.id 时按身份匹配;无 key 时按位置匹配
代码或图示
Column {
items.forEach { item ->
RowItem(item = item)
}
}
常见误区
- 在循环里用 remember 保存列表内状态却不提供 key,删除首项后状态错位。
- 把可变状态直接写在可组合函数的局部 var 上,重组后被重置。
追问
- 循环调用数量变化时槽位如何伸缩?答:新增迭代进入子 group,消失迭代离开组合;槽位按位置排列,key 只影响身份匹配。
- 懒列表与普通 Column 循环有何差异?答:懒布局只组合可见项并回收离屏项,详见布局篇与性能篇。
07.1.1.7.1-011 什么是可组合 lambda(slot),它在组合树中如何记录?
一句话结论
slot 是作为参数传入的可组合 lambda,外层把一段「延迟组合内容」交给内部组件,内部在自己的 group 上下文中执行该 lambda。
概念解释
典型如 Card(content = { Text(...) }),lambda 内部的组件不属于外层调用位置,而在 Card 提供的槽位 group 中组合。这样 Card 可以决定内容放在哪个布局区域,状态订阅与 group 归属跟随实际执行位置。
原理流程
外层调用 Card(content = slotLambda)
→ Card 内部在指定槽位 group 调用 slotLambda
→ lambda 内组件记录在槽位 group 下
代码或图示
Card {
Text("槽位内容") // 记录在 Card 的内容 group 中
}
常见误区
- 以为 lambda 内组件状态归外层函数持有,实际归槽位执行位置。
- 把不可组合的普通 lambda 当 slot 传,编译器按普通参数处理,不参与组合记录。
追问
- slot lambda 是否受稳定性影响?答:作为参数的 lambda 闭包捕获会影响参数稳定性;捕获可变状态可能使该参数不稳定(见稳定性题目)。
- 多个 slot 如何区分?答:组件定义多个 @Composable lambda 参数(如 title/content),各自在独立槽位 group 执行。
07.1.1.7.1-012 可组合项内部为什么不应该持有可变成员状态?
一句话结论
可组合项没有稳定的对象实例对应,函数内部局部 var 在重组时不被保留;需要跨重组保留的状态必须走 remember 或提升到上层。
概念解释
可组合函数不是每次运行都 new 一个组件对象,函数局部变量在每次执行时重新初始化。把计数、选中项写成局部 var 无法跨重组存活;成员可变字段若由外部类持有,也会脱离 Compose 状态驱动体系。
原理流程
局部 var x = 0
→ 本次组合执行
→ 重组再次执行:x 重新初始化为 0
→ 跨重组存活必须 remember { ... } 或提升状态
代码或图示
// 错误:重组后重置
var expanded = false
// 正确:remember 持有
val expanded = remember { mutableStateOf(false) }
常见误区
- 把可组合类当成 Android View 那样持有成员状态。
- 在对象表达式里挂可变字段并期待 Compose 感知变化。
追问
- 跨重组需要保留什么类型的值?答:简单对象用 remember;需要在配置变更后存活用 rememberSaveable;驱动界面的可观察状态用 mutableStateOf。
- 状态归谁更合适?答:可复用、可测试的状态提升到 ViewModel;纯界面临时状态留在组合层 remember。
07.1.1.7.1-013 可组合项被调用时是否等同于创建一个 UI 对象?
一句话结论
不等同。调用可组合项是在组合上下文中记录/更新节点,具体视图对象的创建与复用由 Compose 节点体系与宿主渲染层决定。
概念解释
首次组合时节点被创建;后续重组多数情况下更新既有节点的属性与布局,而不是每次调用都 new 一套控件。在 Android 平台上 Compose 最终通过 OwnedView / 渲染管线落到视图树,但映射不是「一个函数 = 一个 View 实例」。
原理流程
调用可组合项
→ 定位 / 创建对应节点
→ 更新节点属性、约束与绘制描述
→ 宿主渲染层合并到平台视图树
代码或图示
Column {
Text("A") // 节点创建一次,后续重组更新文本
}
常见误区
- 统计调用次数当作控件创建次数,误判内存泄漏。
- 手动 new View 塞进组合结果,破坏节点树管理。
追问
- 节点何时真正销毁?答:group 离开组合、节点树回收时;互操作边界上的 View 释放另见互操作篇。
- 自定义组件能否持有平台 View?答:需要通过 AndroidView 桥接,不要在可组合函数里直接构造 View 并保存。
07.1.1.7.1-014 多个可组合项之间如何通过参数与回调协作?
一句话结论
父组件把状态与事件回调作为参数向下传,子组件回调事件给父组件,形成单向数据流;共享状态在共同祖先处持有。
概念解释
可组合项之间没有直接的父子对象引用协作,接口形态是「输入参数 + 回调 lambda」。子组件不直接改父级状态,而是触发回调,由父级更新状态后再向下传播。
原理流程
父级持有状态
→ 状态值作为参数下发
→ 子组件回调 onXxx
→ 父级更新状态 → 再次下发
代码或图示
@Composable
fun CounterView(count: Int, onIncrement: () -> Unit) {
Button(onClick = onIncrement) { Text("$count") }
}
常见误区
- 子组件直接修改传入的可变对象字段,绕过单向数据流。
- 通过全局静态变量在组件间传状态,破坏可测试性与可预测性。
追问
- 多层组件都需要同一状态时提升到哪一层?答:提升到第一个需要读取该状态的共同祖先;更全局的状态放 ViewModel。
- 回调 lambda 稳定性如何保证?答:捕获不变引用、使用 rememberUpdatedState 或记住稳定回调,避免参数不稳定导致无法跳过。
07.1.1.7.1-015 组合(Composition)与渲染树之间是什么关系?
一句话结论
Composition 是声明式记录与状态层,渲染树是其产物;组合更新节点描述,测量、布局、绘制阶段再把描述落到平台视图与画布上。
概念解释
可组合调用先在 Composition 中形成节点与状态订阅;随后 Compose 布局阶段测量放置节点,绘制阶段生成绘制命令。状态变化先触发组合层更新,再按需驱动布局与绘制,三层不完全同步执行。
原理流程
组合(Composition)→ 节点树与状态
→ 测量 / 布局 → 位置与尺寸
→ 绘制 → 平台视图树 / 渲染命令
代码或图示
状态变更
→ 受影响 group 重组(组合层)
→ 标记需要重新布局 / 绘制的节点
→ 下一帧完成布局与绘制
常见误区
- 把组合阶段耗时全部算成渲染耗时,三者需要在 Profiler 中分开看。
- 以为状态一变就立即重绘整屏,实际按节点层级按需失效。
追问
- 组合层能单独观察吗?答:Layout Inspector 可查看重组计数;Perfetto / Studio Profiler 可区分组合、布局、绘制泳道。
- 渲染树产物保存在哪?答:平台侧视图与绘制节点由 Compose 内部维护,不建议手工编辑构建产物目录。
07.1.1.7.1-016 重组(recomposition)在什么条件下被触发?
一句话结论
被订阅的 State 对象写入新值,且读取该状态的 group 尚未被跳过,Compose 在下一帧调度受影响节点重新执行;参数变化本身不触发重组,只参与跳过判定。
概念解释
重组由快照状态写入驱动:哪个 group 在组合阶段读取了哪个 State,就建立订阅。State 写入后通知订阅者,受影响 group 标记为需要重组。父级参数变化只是重调时的比对输入,不是独立触发源。
原理流程
State.value = newValue
→ 快照记录变更
→ 通知订阅该 State 的 group
→ 下一帧调度这些 group 重新执行(参数可跳过时跳过)
代码或图示
val text = remember { mutableStateOf("a") }
Text(text.value) // 读取订阅;text 写入后本节点重组
常见误区
- 以为父组件一动所有子组件无条件重画,实际按订阅与稳定性跳过。
- 把普通 var 赋值当成可触发重组的状态,它不是快照 State。
追问
- 同一帧多次写入会合并吗?答:快照事务内批量写入,订阅者按帧统一收到变更通知,避免一帧内多次重排。
- 重组在哪个线程执行?答:状态写入可来自后台线程,但组合更新最终在主线程帧调度;具体线程模型见快照状态题目。
07.1.1.7.1-017 状态读取发生在可组合项内部与外部,触发重组有何不同?
一句话结论
在组合执行路径上直接读取 State.value 才建立订阅;在 Effect、回调、协程里读取属于事后读取,不订阅当前 group 的重组。
概念解释
组合阶段函数体执行到 state.value 时,运行时把当前 group 记为订阅者。点击回调里读 state.value 只取得当时值,不建立订阅;因此「回调里改了值但界面没刷新」往往是读取位置不对。
原理流程
组合主体读取 state.value → 建立订阅 → 写入触发本 group 重组
onClick / LaunchedEffect 内读取 → 不订阅组合节点
代码或图示
Text(state.value) // 组合阶段读取,订阅
Button(onClick = { state.value = "x" }) // 回调内写入,不读取
常见误区
- 在 lambda 里读状态拼字符串,期待状态变化时该 lambda 输出自动更新。
- 把状态读取放进 SideEffect,结果界面不随状态刷新。
追问
- 回调里需要取最新值怎么办?答:用 rememberUpdatedState 持有最新引用,或在组合阶段把值作为参数传入回调。
- 订阅建立后何时解除?答:group 离开组合、状态被替换或上下文释放时解除。
07.1.1.7.1-018 参数变化与状态读取分别如何驱动重组?
一句话结论
内部订阅的 State 写入是主动触发源;父级参数变化是重组发生时的比对输入,稳定且未变的参数可让子节点被跳过。
概念解释
父级自身因状态变化重组后,带着新参数遍历子节点。子节点是否重调取决于:参数是否稳定、equals 是否相等、子节点自身是否订阅了变化状态。参数变化不会凭空唤醒一个未订阅的子节点。
原理流程
父级状态写入 → 父级 group 标记重组
→ 遍历时比对子节点参数
→ 稳定且相等:跳过子节点
→ 不稳定或不等:重新执行子节点
代码或图示
// count 变化 → 父级重组;Row 仅在参数变化时比对是否重调
Row(count = count, onClick = { ... })
常见误区
- 认为「父重组 = 子全部重绘」,忽略跳过判定。
- 把内部状态提升成参数后,以为子组件会自己响应参数变化,实际驱动仍来自父级状态订阅。
追问
- 子组件自己订阅状态时谁触发它?答:它直接订阅该 State,写入后由快照通知直达子节点,不必先经过父级重组。
- 参数对象未变但内部字段改了会怎样?答:普通对象字段变化不产生快照通知;若字段是 State 或类型不稳定,结论另见稳定性题目。
07.1.1.7.1-019 重组的作用域是如何划定的(哪些节点会被重新调用)?
一句话结论
作用域以读取该状态的 group 为边界:直接读取状态的可组合项被重调,其子节点按参数稳定性决定是否跟随,祖先节点通常不被牵连。
概念解释
Compose 尽量把重组限制在最小订阅单元。状态在叶子组件读取,叶子被重调;状态在中间层读取,中间层及其未跳过的子树重调。把读取下沉到真正使用状态的组件,是缩小作用域的主要手段。
原理流程
State 写入
→ 找到订阅该 State 的 group
→ 重调这些 group
→ 子节点按参数稳定性逐项跳过或跟随
代码或图示
// 读取下沉:Text 订阅,Column/Button 可跳过
Column { Text(viewModel.uiState.title) }
常见误区
- 一个状态在父层读取后传给多个子节点,导致父层整棵子树都进入重组候选。
- 把大段 UI 写在一个可组合函数里,无法按子节点粒度跳过。
追问
- 如何缩小作用域?答:状态读取局部化、拆小组件、参数保持稳定、避免在大函数顶部读无关状态。
- 作用域能跨 Composition 吗?答:不能,订阅记录在各自 Composition 上下文中。
07.1.1.7.1-020 为什么状态在 Effect 或回调里读取不会触发当前组合项重组?
一句话结论
订阅关系只在组合主体执行时建立;Effect 与回调在组合之外的时机执行,读取行为不登记到当前 group,因此不触发界面重组。
概念解释
LaunchedEffect、DisposableEffect、SideEffect、onClick、协程回调都是组合主体执行之后的独立执行流。它们读取 State 拿到的是当前快照值,运行时不为这些流登记组合订阅。需要界面刷新时,应在组合主体读取,或在回调中写入被主体订阅的状态。
原理流程
组合主体 → 读取并登记订阅
→ Effect / 回调执行 → 读取仅取当前值,不登记
→ 界面更新依赖主体中已订阅的 State 被写入
代码或图示
LaunchedEffect(unit) {
val snapshot = state.value // 此处读取不订阅 UI
}
常见误区
- 在 LaunchedEffect 里读状态拼日志,并期待状态变化触发 effect 重跑(effect 重跑靠 key,不靠读取订阅)。
- 把界面文案计算放进 SideEffect,导致主体渲染不到最新值。
追问
- Effect 什么时候随状态变化重跑?答:key 列表变化时取消旧协程/旧副作用并重新执行;key 不变则不重跑。
- 回调里想用到最新参数怎么办?答:rememberUpdatedState 在主体持有最新引用,回调读取该 State。
07.1.1.7.1-021 一次状态写入会不会合并多次重组,调度时机在哪?
一句话结论
同一帧快照事务内的多次写入会合并通知,重组被调度到下一帧的主线程执行,而不是写一次立刻同步重跑整段 UI。
概念解释
快照系统记录本事务内被修改的状态,提交后统一通知订阅者。Compose 把需要重组的节点加入帧调度,随 Choreographer 帧处理。批量连续赋值不会产生逐次的中间界面。
原理流程
连续多次 state 写入(同一事务 / 同一帧)
→ 快照记录修改集合
→ 帧调度 → 受影响 group 批量重组
→ 跳过未变化节点
代码或图示
state.value = 1
state.value = 2 // 中间值不单独触发一次完整重组
常见误区
- 以为每次赋值都同步刷新界面,导致对重组频率与帧率的误判。
- 在组合主体里连续读写状态,破坏事务一致性。
追问
- 事务边界如何形成?答:写入在可组合主体、Effect 或显式 snapshot 块中;具体快照事务机制见快照状态题目。
- 跨线程写入如何合并?答:最终同样按帧通知到主线程,线程安全由快照模型保证。
07.1.1.7.1-022 重组能否跳过未读取变化状态的可组合项?
一句话结论
能。未订阅变化状态、且传入参数稳定且相等的节点会被跳过;跳过不影响其子树保留既有界面与状态。
概念解释
重组遍历时,编译器生成的跳过检查先看参数稳定性与 equals:稳定参数未变即可跳过该节点,不再执行函数体,子树沿用上次组合结果。不稳定类型会让检查保守失败。
原理流程
遍历子节点
→ 参数稳定?equals 未变?
→ 是:跳过(skippable),子树保留
→ 否:重新执行函数体
代码或图示
@Composable
fun Avatar(url: String) { /* 稳定参数未变时可跳过 */ }
常见误区
- 跳过节点误以为其子节点也一定被跳过,子节点按自身参数与订阅独立判定。
- 跳过等于不绘制,实际只是不重跑组合主体,绘制结果保留。
追问
- 如何验证节点被跳过?答:Layout Inspector 查看跳过计数,或加日志观察函数体执行次数。
- 哪些参数导致跳不过?答:不稳定类、可变集合、捕获可变引用的 lambda、泛型未约束类型等。
07.1.1.7.1-023 重组是否保证每个可组合项每次状态变化后都重新执行?
一句话结论
不保证。Compose 按订阅、稳定性与跳过判定增量更新;未受影响或可跳过的节点不会重新执行函数体。
概念解释
「状态变了」只覆盖订阅该状态的节点;其余节点可能被跳过。即使在受影响子树内,稳定参数未变的子节点也会跳过。理解这一点才能解释为什么加日志后函数并不每帧运行。
原理流程
状态变更 → 通知订阅者
→ 受影响 group 入队
→ 执行跳过检查 → 可跳过则不重跑
代码或图示
// 仅订阅 state 的节点进入重组候选
Text(state.value)
常见误区
- 用「每次重组都全量重跑」去估算性能,实际重组是增量的。
- 把函数体没有执行当作状态没有传播,可能只是节点被跳过。
追问
- 什么情况下必须重跑?答:订阅的状态变化、参数不稳定或不等、节点不可跳过(non-skippable)。
- 不可跳过的原因有哪些?答:存在不稳定参数、编译器认定该函数不具备跳过条件,具体规则见稳定性题目。
07.1.1.7.1-024 状态在 if 分支或 lambda 中读取,订阅范围如何确定?
一句话结论
订阅登记在实际执行到读取语句的 group 上:if 内读取只订阅该分支 group;slot lambda 内读取订阅 lambda 执行位置所在 group。
概念解释
读取语句所在的执行路径决定订阅归属。if 条件为假时分支不执行,读取不发生,订阅也不登记。lambda 被组件在槽位中调用时,读取记到槽位 group,而不是 lambda 定义处。
原理流程
if (flag) { Text(state.value) } // flag 为真时该分支订阅
Card { Text(state.value) } // 订阅 Card 内容槽位 group
代码或图示
if (loading) {
ProgressBar(state.value)
}
常见误区
- 在定义 lambda 的外层期待订阅跟随 lambda 声明位置。
- 把状态读取写进不会执行的防御分支,以为界面会响应。
追问
- 分支切换后订阅如何变化?答:进入分支登记订阅,离开分支解除;分支内 remember 状态随 group 离开回收。
- 同一段读取被两个分支复用怎么办?答:提取成独立可组合项,订阅归提取出的节点 group。
07.1.1.7.1-025 首次组合(initial composition)与后续重组走的是同一条路径吗?
一句话结论
两者共享同一套组表与节点记录机制,但首次组合负责创建节点与槽位,重组负责定位既有 group 并做跳过或更新。
概念解释
首次组合顺序执行全部可组合调用,创建节点、分配 remember 槽位、登记订阅;重组在既有组表上按索引/key 定位,比对参数与状态,执行跳过、更新或增删 group。路径相似但起点不同。
原理流程
首次组合:建 group → 建节点 → 分配槽位 → 登记订阅
重组:定位 group → 跳过检查 → 更新 / 复用 / 增删 group
代码或图示
首帧:完整遍历组合树
后续帧:按订阅增量处理受影响 group
常见误区
- 把首次组合的成本当成重组成本去对比,首帧包含节点创建与布局初始化。
- 以为重组会重建整棵树,实际多数节点复用。
追问
- 配置变更后是首次组合还是重组?答:界面宿主重建但状态经 rememberSaveable 恢复,节点树可由 Compose 保留;是否完全复用取决于实现与宿主,标「待确认」时以目标版本实测为准。
- 首帧耗时高优先优化哪段?答:减少首屏组合节点数、拆分非首屏内容、避免重初始化计算。
07.1.1.7.1-026 参数相等时可组合项为什么会被跳过(skippable)?
一句话结论
编译器确认参数类型稳定且 equals 相等时,生成跳过分支:不执行函数体,保留上次组合结果,从而降低重组范围与成本。
概念解释
可跳过性由参数稳定性推导。稳定原始类型、不可变对象、稳定 lambda 都参与 equals 比对;相等即跳过。不稳定类型无法证明相等,编译器保守地不生成跳过分支。
原理流程
进入子节点
→ 逐个参数检查稳定性与相等性
→ 全部稳定且相等 → 跳过函数体
→ 任一不稳定或不等 → 重新执行
代码或图示
@Composable
fun Label(text: String, enabled: Boolean) { /* 稳定参数 */ }
常见误区
- 跳过只看引用相等,实际稳定类型走 equals;不可变数据类字段相等也可跳过。
- 以为自定义类默认稳定,未标注且含可变字段时不稳定。
追问
- 数据类默认算稳定吗?答:字段均为稳定不可变类型时可被推导稳定;含可变集合或自定义不稳定字段时例外,以编译器报告为准。
- 跳过对 lambda 有何要求?答:未捕获可变状态、捕获值稳定的 lambda 才可能稳定。
07.1.1.7.1-027 重组中重新调用可组合项时,旧的子组合树如何保留?
一句话结论
节点与 remember 槽位保存在既有 group 中,重组只更新变化部分;未跳过子树的节点、状态与订阅原样保留,不随函数体重建。
概念解释
即使父级重新执行函数体,其子 group 仍按位置保留。只有离开组合的 group 才销毁子树。重组重调父级不等于清空子树,这也是内部 remember 状态能跨重组存活的基础。
原理流程
父级 group 重调
→ 遍历子 group:保留、跳过或更新
→ 未离开组合的子树沿用既有节点与槽位
代码或图示
Column {
Child() // 父级重组时 Child 子树尽量保留
}
常见误区
- 父函数体重跑就清空子组件状态,导致错误地把状态提升到父级。
- 混淆「函数体执行」与「节点重建」两个动作。
追问
- 什么情况下子树会重建?答:group 离开组合、key 改变、结构顺序错位到无法对位匹配时。
- 保留的依据是什么?答:组表位置与 key;结构不稳定时需要显式 key 保护。
07.1.1.7.1-028 状态写入在后台线程是否安全,重组回调在哪个线程?
一句话结论
快照 State 的写入可在后台线程完成且线程安全;组合更新与界面回调最终调度到主线程帧执行,UI 节点只能在主线程操作。
概念解释
mutableStateOf 内部用快照机制记录修改,跨线程读写有一致性保证。写入后通知被排队到主线程触发重组;直接在后台线程操作平台 View 仍不允许。协程更新 State 是常见模式。
原理流程
后台线程写入 State
→ 快照记录变更(线程安全)
→ 通知排队回主线程
→ 主线程帧调度受影响 group 重组
代码或图示
scope.launch(Dispatchers.IO) {
state.value = loadResult() // 写快照状态是安全的
}
常见误区
- 认为 State 只能在主线程写,实际快照状态支持跨线程;但 UI 渲染仍归主线程。
- 在后台线程直接修改 Compose 节点属性或平台 View。
追问
- 读取快照状态有线程一致性问题吗?答:不同线程读到的是各自快照视图;事务内可见性规则由快照模型保证,复杂事务行为以官方文档为准(标「待确认」时实测)。
- 协程作用域怎么拿?答:rememberCoroutineScope,随组合离开取消。
07.1.1.7.1-029 如何定位一个可组合项订阅了哪些状态?
一句话结论
看组合主体内直接读取的 State / StateFlow 桥接状态;Layout Inspector 与调试日志可辅助观察订阅关系与重组触发来源。
概念解释
订阅清单由主体代码决定:每个 xxx.value 读取对应一个 State 订阅。Effect、回调中的读取不计入。定位时先读源码找读取点,再用 Inspector 看该节点是否随状态写入重组。
原理流程
源码扫描主体内 .value / collectAsState 读取点
→ 列出对应 State
→ Inspector 观察写入后哪些节点重组 / 跳过
代码或图示
Text(viewModel.uiState.title) // 订阅 uiState.title 对应状态
常见误区
- 把传入参数里的 State 当成节点直接订阅,订阅归属以实际读取位置为准。
- 只看变量名不看读取语句,误判订阅范围。
追问
- collectAsState 建立的订阅是什么?答:Flow 收集后把当前值转成 Compose State,节点订阅该桥接 State。
- 多个状态写入一次重组如何分清来源?答:结合日志时间线、状态写入点与 Inspector 重组计数对照。
07.1.1.7.1-030 读取状态的时机为什么会影响重组范围(deferred read)?
一句话结论
读取越靠近真正使用状态的叶子组件,订阅作用域越小;在父层提前读取再向下传值,会把订阅扩大到父层,父层整段子树进入重组候选。
概念解释
「deferred read」指把读取延迟到消费该值的最小组件中。父层读取后只传递普通值,父层成为订阅者;子组件拿到值反而不订阅原始 State。读取下沉可以避免大段 UI 跟随无关状态刷新。
原理流程
父层读 state.value → 父层订阅 → 父层重组候选
→ 子组件收普通值(不订阅)
下沉到子组件读取 → 仅叶子节点订阅重组
代码或图示
// 反例:父层读取
Column { Text(profile.name) }
// 改进:把 profile 下传,由 Avatar 内部读取
Column { Avatar(profile) }
常见误区
- 在大容器顶部读取一个只影响局部按钮的状态,造成整容器重排。
- 误以为「传值」本身也算子组件订阅。
追问
- 状态需要在多处使用怎么办?答:在各消费组件分别读取,或提升到 ViewModel 用 Flow 分流;避免在公共祖先集中读取后广播。
- deferred read 与稳定性如何配合?答:下沉读取后参数保持稳定,子节点更容易被跳过。
07.1.1.7.1-031 可组合项内分配对象是否会在每次重组时重复执行?
一句话结论
函数体在重组时被重新执行,函数体内的对象分配语句随之再次执行;需要跨重组复用的对象必须 remember,重计算结果应派生缓存。
概念解释
数组、列表、画笔、适配器等如果直接写在主体里,每次重跑都会新建。轻量小对象问题不大,频繁重组下大对象分配会增加 GC 压力。复用对象用 remember,派生值用 derivedStateOf 或 remember 缓存。
原理流程
重组重跑函数体
→ 未 remember 的局部对象再次分配
→ 高频重组时分配速率上升,GC 压力增大
代码或图示
val padding = remember { PaddingValues(16.dp) }
val filtered = remember(items) { items.filter { it.active } }
常见误区
- 在主体里 new 列表/回调并直接传给子组件,既分配又可能让 lambda 参数不稳定。
- 把重计算(排序、过滤)放在主体每次执行时跑。
追问
- 哪些对象适合 remember?答:布局参数、画笔、路径、派生集合、稳定回调;状态本身用 mutableStateOf 持有。
- remember key 如何选?答:依赖的输入变化时重算,key 与重算条件一一对应。
07.1.1.7.1-032 重组是否可能并行执行同一个组合树的不同部分?
一句话结论
组合更新与节点操作在 Android 平台上以主线程为主;快照状态写入可跨线程,但不代表同一棵组合树被多个线程并行重跑。
概念解释
Compose 的组合记录与节点树不是线程安全的随机访问结构,UI 组合、布局、绘制在主线程帧内完成。并行化体现在后台取数、状态写入与协程处理上,界面重组不应当作多线程并发执行来设计。
原理流程
后台协程计算 / 写状态
→ 结果快照化
→ 主线程帧内串行完成受影响组合、布局、绘制
代码或图示
scope.launch(Dispatchers.IO) {
val data = fetch()
uiState.value = data // 后台写,主线程刷新
}
常见误区
- 为「并行重组」加锁保护组合节点,方向错误。
- 在子组件组合主体里开线程改 UI 节点。
追问
- 平台渲染管线有后台线程吗?答:渲染、GPU 合成可由系统图形管线处理,但组合与布局交互仍在主线程;具体线程划分以 Perfetto 泳道为准。
- 多线程状态共享怎么保证一致?答:统一走快照 State 或线程安全的 ViewModel 状态容器。
07.1.1.7.1-033 状态对象引用不变、内部字段变化,会触发重组吗?
一句话结论
不会自动触发。普通可变字段变化不产生快照通知;只有字段本身是被读取的快照 State,或整体替换为新 State 值,订阅者才收到通知。
概念解释
持有一个普通可变类实例,改其 field = x 不会通知 Compose。可观察性来自 mutableStateOf 包装的字段或不可变数据类整体替换。把数据类字段改成普通 var 后,界面可能不刷新。
原理流程
普通对象.field = x → 无快照通知 → 已订阅节点不重排
State 包装字段写入 / 整体 copy 替换 → 快照通知 → 订阅重组
代码或图示
data class UiState(val name: String)
// 正确:整体替换不可变副本
state.value = state.value.copy(name = newName)
常见误区
- 直接修改传入的可变列表/对象字段,期待 UI 跟随刷新。
- 把 State 包在普通类的可变 var 里,却没有暴露可观察读取点。
追问
- 集合内元素改了怎么办?答:用不可变集合 + 整体替换新列表;可变 List 作为 State 值时也要替换引用。
- 如何让自定义类可观察?答:字段用
mutableStateOf委托,或在边界上使用不可变数据类并整体更新。
07.1.1.7.1-034 同一个状态被多个可组合项读取,通知如何分发?
一句话结论
State 记录所有订阅 group,写入后逐个通知;同一帧内受影响节点一起入队,各自独立做跳过判定,互不强制连带。
概念解释
订阅列表按 group 登记,一个 State 可被多个组件读取。写入通知遍历订阅者,每个订阅节点独立决定是否重调。取消订阅发生在对应 group 离开组合时。
原理流程
State 写入
→ 遍历订阅 group 集合
→ 各自标记重组候选
→ 帧调度中逐项跳过检查
代码或图示
Title(state.value)
Subtitle(state.value) // 同一 State 的第二个订阅者
常见误区
- 以为通知会沿树冒泡强制刷新父级,实际直达订阅 group。
- 重复读取同一状态多次登记订阅,实际同一 group 内重复读取不会无限叠加。
追问
- 订阅集合在什么时机更新?答:组合进入登记、离开解除;状态对象替换为新实例时旧订阅随之失效。
- 多个节点订阅同一状态,通知顺序有保证吗?答:按组树顺序处理,避免依赖具体通知顺序写业务逻辑。
07.1.1.7.1-035 为什么不要在可组合项执行过程中直接修改被读取的状态?
一句话结论
组合主体应当是只读计算过程;在执行中改写正在读取的 State 会造成不一致视图与重复通知,写操作应放到回调或 Effect 中。
概念解释
重组基于当前快照计算界面,主体内立刻改写状态会让本次组合读到新旧混杂的值,还可能触发额外重组循环。事件驱动的写入放在 onClick、Effect、ViewModel 方法中,主体只读取与渲染。
原理流程
主体读取 state
→ 主体内修改 state → 快照视图不一致 / 触发二次重组
正确:主体只读;写入由事件回调或 Effect 发起
代码或图示
// 反例:组合过程中改状态
Text("${state.value}")
// state.value = "x" // 不允许放在主体
常见误区
- 在初始化分支里直接累加计数,造成重组时数值跳变。
- 把派生逻辑写成「读-改-写」闭环放在主体。
追问
- 需要首次进入时初始化状态怎么办?答:用 LaunchedEffect(key) 或在 ViewModel 初始化;remember 初值只做一次性惰性构造。
- 读取后需要派生另一个状态?答:用 derivedStateOf 派生,而不是在主体写回 State。
07.1.1.7.1-036 remember 的作用是什么,它把值存在哪里?
一句话结论
remember 在当前 group 的槽位中缓存一个值,跨重组保留;离开组合后槽位回收,值随之丢弃。
概念解释
remember 接受一个工厂 lambda,首次组合时执行并把结果存入 group 槽位;后续重组直接取回缓存值。它解决「函数局部变量重跑即重置」的问题,但不保证配置变更或进程死亡后存活。
原理流程
首次组合 → 执行工厂 lambda → 存入 remember 槽位
→ 重组 → 直接取槽位值,不重跑工厂
→ 离开组合 → 槽位回收
代码或图示
val list = remember { mutableListOf<String>() }
常见误区
- 把 remember 当成持久化存储,旋转屏幕后值可能丢失。
- 在 remember 工厂里写副作用请求,工厂只在首次组合执行一次。
追问
- remember 缓存的是对象还是引用?答:缓存工厂返回的引用;可变对象被外部修改时 remember 不做快照拷贝。
- 需要配置变更存活用什么?答:rememberSaveable,按可保存状态序列化到容器中。
07.1.1.7.1-037 remember 与直接在参数中持有对象有何区别?
一句话结论
remember 的值归当前组合位置持有,跨重组保留;函数参数来自父级,每次重组按父级传入的值比对,不存在本地缓存槽位。
概念解释
参数是输入,稳定性比对决定节点是否跳过;remember 是本地缓存,不参与父级参数相等性判定。把需要本地复用的对象写在参数里,会随父级重传而反复新建或覆盖。
原理流程
参数:父级传入 → 比对 equals → 使用传入值
remember:本地槽位 → 首次构造 → 后续复用缓存
代码或图示
@Composable
fun Panel(items: List<Item>) {
val mapper = remember(items) { ItemMapper(items) }
}
常见误区
- 用参数对象在组件内缓存派生结果,参数一变缓存就被覆盖。
- 把本地状态当参数下传,造成双向耦合。
追问
- 派生对象依赖输入变化怎么刷新?答:remember 的 key 传入依赖项,key 变化时重新执行工厂。
- 参数对象本身需要复用怎么办?答:在父级或 ViewModel 侧稳定引用,配合稳定性注解。
07.1.1.7.1-038 remember 的 key 参数如何驱动重新计算?
一句话结论
remember(key1, key2) 在任一 key 与上次不同时重新执行工厂;key 相等则沿用缓存值。
概念解释
key 用于标识缓存有效性。输入数据、选中项、外部参数变化时,把它们作为 key,remember 自动重算派生结果。key 比较走 equals,稳定类型才有确定的相等判定。
原理流程
首次:执行工厂,记录 key 快照
→ 重组:比对新 key 与旧 key
→ 全部相等:沿用缓存
→ 任一不等:重跑工厂并更新槽位
代码或图示
val filtered = remember(query, list) {
list.filter { it.contains(query) }
}
常见误区
- 依赖可变对象内部变化却不把新引用作为 key,缓存不刷新。
- 传入不稳定类型作为 key,相等判定不可靠。
追问
- key 传集合时注意什么?答:用不可变集合或稳定包装;普通可变 List 引用不变不算变化。
- 多个 key 变化会重算几次?答:同一次重组内比对整体 key 集合,重算一次并更新缓存。
07.1.1.7.1-039 remember 缓存的值在什么时机被清除?
一句话结论
group 离开组合时槽位清除;key 变化只替换缓存值,不是清除;配置变更未保留时 remember 值丢失。
概念解释
离开组合包括条件分支消失、列表项回收、导航退出、Composition 释放。key 触发重算时旧值被新值替换。remember 不写回 Bundle,配置变更重建宿主后默认不可用。
原理流程
key 变化 → 槽位替换为新值
→ group 离开组合 → 槽位整体回收
→ 配置变更 → remember 默认不存活(需 rememberSaveable)
代码或图示
if (editing) {
val draft = remember { mutableStateOf("") } // 离开分支即回收
}
常见误区
- 导航返回后期待 remember 值还在,实际离开组合已清除。
- key 变化后以为旧对象被立即 GC,引用仍可能滞留到下次回收。
追问
- 如何确认值被清除?答:观察 DisposableEffect.onDispose 回调与再次进入时工厂是否重新执行。
- 哪些场景必须换 rememberSaveable?答:输入草稿、滚动位置、选中项等配置变更后应保留的界面状态。
07.1.1.7.1-040 rememberSaveable 相比 remember 多保留了什么?
一句话结论
rememberSaveable 在 remember 基础上把可序列化状态存入保存容器,配置变更与进程临时回收后可恢复;普通 remember 只在内存组合槽位中保留。
概念解释
rememberSaveable 委托 SavedState 机制,值被保存到 Bundle 等价结构中。旋转屏幕、Activity 重建时恢复;进程被系统回收后由保存状态恢复小体积数据。大对象、不可序列化对象不能直接保存。
原理流程
首次组合 → 构造值并写入保存容器
→ 配置变更 / 进程临时回收 → 容器保留
→ 重建 → 从容器恢复值
代码或图示
val query = rememberSaveable { mutableStateOf("") }
常见误区
- 用 rememberSaveable 保存图片、列表大对象,受可保存类型与体积限制。
- 把 ViewModel 职责的业务状态塞进 Saveable,导致状态恢复口径混乱。
追问
- 哪些类型默认可保存?答:基本类型、String、Parcelable、Serializable、Saver 支持的类型;具体可用集合与版本边界以官方文档为准(待确认时实测)。
- 恢复后状态不一致怎么办?答:检查 Saver 读写规则与键冲突,避免容器被覆盖。
07.1.1.7.1-041 rememberSaveable 的保存机制(Bundle / Saver)如何工作?
一句话结论
默认走类型匹配的 Saver 把值序列化进保存容器;自定义类型通过 Saver 定义保存(save)与恢复(restore)两个函数,挂到 rememberSaveable(stateSaver = ...)。
概念解释
保存容器在配置变更间保留。内置 Saver 处理常见可保存类型;自定义对象拆成可保存字段组合保存,恢复时重建实例。State 包装也有对应 Saver 规则。
原理流程
save:对象 → 拆成可保存字段 → 写入容器
restore:容器字段 → 重建对象 → 放回 remember 槽位
代码或图示
val saver = Saver<Profile, Any>(
save = { listOf(it.name, it.age) },
restore = { Profile((it as List<*>)[0] as String, (it)[1] as Int) }
)
val profile = rememberSaveable(stateSaver = saver) { mutableStateOf(Profile("", 0)) }
常见误区
- 自定义类型直接传保存容器,运行时提示无法保存。
- Saver restore 类型断言不严谨,恢复时抛异常。
追问
- Saver 与 Parcelable 什么关系?答:实现 Parcelable 的类型可直接走平台序列化;Saver 是 Compose 层的通用抽象,二者可配合。
- 保存键冲突如何排查?答:不同 owner 状态各自存于对应保存槽,跨页面复用键会互相覆盖。
07.1.1.7.1-042 配置变更与进程死亡两种场景下,状态保留有何差异?
一句话结论
配置变更(旋转、字体切换)走保存容器快速重建,rememberSaveable 可恢复;进程被系统回收后内存对象销毁,只有写入保存容器的小状态可恢复,业务数据需持久化。
概念解释
配置变更销毁重建宿主但保存容器保留;进程回收后内存堆清空,SavedState 仍可由系统恢复关键界面状态。remember 内存值在两种场景下都默认丢失。
原理流程
配置变更:宿主重建 → 保存容器存活 → rememberSaveable 恢复
进程回收:堆清空 → 容器在恢复包中 → 仅可保存字段恢复
业务数据:数据库 / 网络 / 本地持久层负责恢复
代码或图示
界面草稿 → rememberSaveable
列表数据 → ViewModel + 本地缓存 / 数据库
常见误区
- 认为 ViewModel 能扛进程回收,它只存活到配置变更,不解决进程死亡后的数据恢复。
- 把大列表状态保存进 Saveable,超出序列化体积预期。
追问
- 如何模拟进程回收验证?答:开发者选项「不保留活动」或后台杀掉进程后重新进入,检查草稿与选中项是否恢复。
- 恢复时机在哪?答:宿主重建后组合阶段从容器取回值,首帧即为恢复后状态。
07.1.1.7.1-043 如何为自定义类型实现 Saver?
一句话结论
把自定义对象拆解为平台可保存的基本类型、列表或 Bundle 结构,实现 save 与 restore,再通过 rememberSaveable(stateSaver) 挂载。
概念解释
Saver 是类型间转换层:save 输出可存值,restore 从可存值构造对象。嵌套自定义类型逐层拆解;注意恢复时的类型检查与默认值兜底。
原理流程
自定义对象
→ save:拆成 List / Map / 基本字段
→ 存入容器
→ restore:读取字段并重建对象,异常时给默认值
代码或图示
data class Draft(val title: String, val tag: String)
val DraftSaver = Saver<Draft, Map<String, Any?>>(
save = { mapOf("title" to it.title, "tag" to it.tag) },
restore = {
Draft(it["title"] as? String ?: "", it["tag"] as? String ?: "")
}
)
常见误区
- restore 直接强转未做兜底,容器缺字段时崩溃。
- 在 Saver 里执行 IO 或异步重建,恢复路径同步执行。
追问
- 嵌套对象怎么保存?答:逐层 Saver 嵌套拆解,或只保存可重建的关键 id,恢复时重新加载。
- Saver 注册在哪里?答:随 rememberSaveable 参数传入,不需要全局注册。
07.1.1.7.1-044 rememberUpdatedState 解决什么问题,典型场景是什么?
一句话结论
它在组合层持有最新值的 State,供长生命周期回调(协程、监听器、定时器)始终读取最新参数,而不是捕获过期闭包值。
概念解释
lambda 捕获的参数在创建时固定;回调长期运行时参数可能已更新。rememberUpdatedState 在每次组合更新包装值,回调读取 .value 拿到最新引用,避免旧值残留。
原理流程
组合执行 → updatedState.value = 最新参数
→ 旧协程 / 监听器读取 updatedState.value → 拿到当前值
代码或图示
@Composable
fun EffectBox(onTimeout: () -> Unit) {
val current by rememberUpdatedState(onTimeout)
LaunchedEffect(Unit) {
delay(3000)
current() // 调用最新的回调
}
}
常见误区
- 把回调直接捕获进 LaunchedEffect(Unit),参数更新后旧协程仍调旧闭包。
- 以为 rememberUpdatedState 会触发重组,它只是同步最新引用,不新增订阅。
追问
- 它与 remember(key) 区别?答:rememberUpdatedState 不重跑 effect,只更新包装值;需要 effect 重跑时用 key 驱动 LaunchedEffect。
- 适用哪些回调?答:定时器、订阅回调、平台监听器、跨线程回调等长生命周期入口。
07.1.1.7.1-045 rememberUpdatedState 与直接在回调中捕获参数有何区别?
一句话结论
直接捕获锁定的是 lambda 创建时刻的值;rememberUpdatedState 包装后每次组合刷新,回调在执行时刻读取到的是最新值。
概念解释
普通闭包按引用捕获变量,但若参数是函数调用入参,旧 lambda 绑定旧实参。更新 State 包装解决的是「旧回调长期持有旧实参」的问题;被包装的必须是会随组合更新的值。
原理流程
直接捕获:旧回调 → 读取旧实参
updatedState:每次组合更新 .value → 旧回调读取当前最新实参
代码或图示
val latest by rememberUpdatedState(text)
DisposableEffect(latest) { /* 回调内读 latest */ onDispose { } }
常见误区
- 对本身就是 State 的值还包一层,冗余且增加理解成本。
- 在回调里读取 updatedState 之外的旧参数,仍拿不到最新值。
追问
- 回调本身需要替换怎么办?答:要么用 rememberUpdatedState 包回调,要么把回调作为 LaunchedEffect key 触发重启;按生命周期选择。
- 值是可变对象引用时还需要包吗?答:引用不变、内容原地改则旧引用可见新内容;引用整体替换时才需要包装刷新。
07.1.1.7.1-046 rememberCoroutineScope 创建的协程作用域何时取消?
一句话结论
作用域绑定当前 Composition,group 离开组合时自动取消该作用域下启动的所有协程。
概念解释
rememberCoroutineScope 返回一个 Composition 关联的 CoroutineScope,组件内可在回调中启动协程。离开组合时取消协程,避免回调更新已销毁界面造成泄漏。作用域使用主线程调度器为默认上下文。
原理流程
组合中获取 scope
→ 点击 / 事件中 scope.launch { ... }
→ group 离开组合 → scope 取消 → 子协程一并取消
代码或图示
val scope = rememberCoroutineScope()
Button(onClick = { scope.launch { submit() } }) { Text("提交") }
常见误区
- 把 scope 传到 ViewModel 或单例中长期持有,离开组合后仍在更新 UI。
- 用 GlobalScope 替代,导致页面退出后协程泄漏。
追问
- scope 的调度器默认是什么?答:以主线程 Dispatcher 为基础(具体实现版本以官方文档为准),后台任务需在协程内切换 Dispatcher。
- 需要跨页面存活的协程放哪?答:ViewModel 的 viewModelScope,生命周期独立于界面组合。
07.1.1.7.1-047 remember 块内执行初始化逻辑要注意什么副作用风险?
一句话结论
remember 工厂只保证首次组合执行,但在配置变更、key 变化、调试重组下执行时机需要谨慎;有副作用的初始化应交给 Effect,不要依赖工厂只跑一次。
概念解释
工厂 lambda 在槽位首次分配时执行,理论上可用于惰性构造对象。但它不是生命周期回调,调试模式下组合可能多次进入,工厂行为不应依赖唯一执行。写库、发请求、注册监听必须放 Effect。
原理流程
工厂:构造纯对象 / 派生配置(可接受)
→ 副作用注册:放 DisposableEffect
→ 异步加载:放 LaunchedEffect / ViewModel
代码或图示
val formatter = remember { NumberFormatter() } // 纯构造可接受
常见误区
- 在 remember 工厂里注册广播或打开数据库连接,离开组合时无人释放。
- 假设工厂在生产环境永远只执行一次,用它做计数或埋点。
追问
- 纯构造函数有副作用怎么办?答:先解耦成无副作用构造,副作用在 Effect 中补做。
- key 变化时旧对象需要清理吗?答:需要释放资源的对象走 DisposableEffect 管理,remember 只持有引用。
07.1.1.7.1-048 mutableStateOf 直接在可组合项中声明而不 remember 会怎样?
一句话结论
每次重组都会新建一个状态对象,旧状态与界面订阅丢失,表现为状态无法保留、输入被重置。
概念解释
val state = mutableStateOf(...) 写在主体局部,重组重跑时重新赋值,新 State 没有历史订阅,界面回到初值。需要跨重组保留的状态必须 remember { mutableStateOf(...) },或提升到上层。
原理流程
重组重跑主体
→ 新建 MutableState 实例
→ 旧订阅失效,界面读取新初值
代码或图示
// 错误
val name = mutableStateOf("")
// 正确
val name = remember { mutableStateOf("") }
常见误区
- 以为 mutableStateOf 自带记忆能力,它只是可观察状态对象,保存仍靠 remember。
- 在参数回调里新建 State 传回父级,造成多份状态。
追问
- 不 remember 但状态来自上层参数可以吗?答:上层持有的 State 引用传入是可以的,本地新建才需要 remember。
- 用 by 委托时这个坑还在吗?答:
val name by remember { mutableStateOf("") }才正确,漏 remember 同样重置。
07.1.1.7.1-049 key 变化时旧值与新值的生命周期如何衔接?
一句话结论
key 变化触发工厂重算,旧槽位值被新值替换;旧值没有自动 dispose 回调,需要释放资源时应配合 DisposableEffect 观察 key 变化。
概念解释
remember 只负责缓存引用,不管理对象资源释放。key 变化后旧对象失去槽位引用,等待 GC;持有监听器、文件句柄、订阅的对象必须用 Effect 在 key 变化时先释放旧资源再建立新资源。
原理流程
key 不变 → 沿用旧值
key 变化 → 工厂重算,槽位替换为新值
→ 资源释放:DisposableEffect(key) 中 onDispose 清理旧资源
代码或图示
DisposableEffect(channel) {
val sub = channel.observe(::onEvent)
onDispose { sub.cancel() }
}
常见误区
- 依赖 remember 槽位替换自动关闭旧订阅,导致泄漏。
- key 频繁变化时反复重建重资源对象,缺少缓存策略。
追问
- 旧值什么时候被回收?答:失去引用后由 GC 回收;具体时机不保证,资源类对象必须显式释放。
- 如何在替换前保存旧值?答:把旧值保留在上层状态,或用显式缓存映射。
07.1.1.7.1-050 rememberSaveable 可以保存哪些类型,Parcelable 边界是什么?
一句话结论
内置支持基本类型、String、Serializable、Parcelable 及对应集合;自定义非可序列化类型需 Saver 拆解,Parcelable 类型按平台保存通道处理。
概念解释
保存容器能力受平台 Bundle 等价结构约束。复杂对象、匿名类、持有运行时资源(如 View、回调、流)的对象不能直接保存。Parcelable 跨进程/重建时走平台序列化,字段也要符合可保存要求。
原理流程
可保存:基本类型 / String / Parcelable / Serializable / 集合
不可直接保存:View、回调、流、图片位图、大对象
→ 自定义类型:Saver 拆解为可保存字段
代码或图示
val id = rememberSaveable { mutableStateOf("item-1") }
常见误区
- 把 Bitmap 或自定义 listener 直接放进 Saveable。
- Parcelable 内部持有不可序列化字段,恢复时字段为空。
追问
- 类型不在内置列表时怎么验证?答:先跑配置变更与进程回收场景,观察恢复结果;失败再补 Saver。
- 保存体积有上限吗?答:系统对保存状态大小有约束,超限会被丢弃或告警;关键大状态走持久层。
07.1.1.7.1-051 多个 remember 之间的执行顺序为什么稳定?
一句话结论
remember 槽位按组合主体中的声明顺序分配到当前 group,重组沿同一顺序对位读取,因此顺序稳定且不能动态增删。
概念解释
组表槽位是有序序列,函数体每次执行按相同顺序访问槽位。条件分支内的 remember 只在分支进入时占用对应位置;在不同条件下声明数量不同会造成槽位错位,这也是分支结构要稳定的原因之一。
原理流程
主体声明顺序: remember A → remember B → remember C
→ 重组按同序取槽位
→ 分支增删 remember → 槽位位置错位风险
代码或图示
val a = remember { ... }
val b = remember { ... }
常见误区
- 在 if 分支里增删 remember,导致槽位与状态错配。
- 循环内 remember 数量随数据变化而不提供稳定 key。
追问
- 顺序错位会怎样表现?答:状态串到相邻组件、恢复值错误;排查时检查分支内 remember 数量与顺序。
- 如何规避?答:可变数量的状态放进列表/集合由单一 remember 持有,或用 key 锚定。
07.1.1.7.1-052 remember 在 CompositionLocal 提供值变化时会重算吗?
一句话结论
remember 本身不监听 CompositionLocal;读取 local.current 的组件会订阅该局部值,local 变化触发对应 group 重组,但 remember 缓存只在 key 变化时重算。
概念解释
CompositionLocal 的读取登记订阅,与 remember 槽位是两套机制。局部值变化后重组,若 remember key 未变仍沿用缓存;派生结果依赖局部值时应把局部值纳入 key 或直接读取参与计算。
原理流程
Local 变化 → 读取 local.current 的 group 重组
→ remember(key):key 不变 → 缓存沿用
→ 派生结果需要刷新:把 local 值加入 key
代码或图示
val colors = LocalColorScheme.current
val formatter = remember(colors) { Formatter(colors.primary) }
常见误区
- 缓存了依赖主题色的对象,主题切换后颜色不更新。
- 没读 local.current 却期待组件随主题刷新。
追问
- CompositionLocal 变化如何传播?答:provide 作用域内向下继承,读取点订阅,离开作用域恢复默认值。
- 局部值不稳定会影响跳过吗?答:会,读取本身参与重组判定;局部值类型也应稳定。
07.1.1.7.1-053 如何用 remember 派生一个依赖状态的计算值?
一句话结论
用 remember(依赖项) 包裹纯派生计算,依赖不变沿用缓存,依赖变化重算;高频收敛场景可进一步用 derivedStateOf 限制下游重组。
概念解释
过滤、排序、格式化等纯函数结果可缓存。key 传参与派生结果相关的状态;计算必须无副作用。若派生值只在少量边界变化,直接 remember 会随每次依赖重组重算,derivedStateOf 可在内部收敛后再通知下游。
原理流程
依赖输入变化
→ remember 比对 key → 重算派生值
→ 高收敛派生:derivedStateOf 内部判定结果是否变化
代码或图示
val visible = remember(items, query) {
items.filter { it.matches(query) }
}
常见误区
- 派生计算写在主体每次重组都跑,缺少缓存。
- key 漏传依赖项,结果滞后。
追问
- remember 与 derivedStateOf 怎么选?答:派生结果每次输入都可能用、重算便宜用 remember;派生值与 UI 订阅边界相关、只需在结果跨阈值变化时通知用 derivedStateOf。
- 派生集合返回新引用会影响子组件跳过吗?答:会,引用变化使不稳定集合参数无法跳过。
07.1.1.7.1-054 rememberUpdatedState 与 LaunchedEffect 配合时如何保证回调取到最新值?
一句话结论
Effect 以 Unit 或稳定 key 长期运行时,用 rememberUpdatedState 包装回调/参数;effect 内读取包装值,保证旧协程调用的是最新闭包。
概念解释
LaunchedEffect(key) 的协程在 key 不变期间持续运行,捕获的是创建时的回调。参数更新后不重启协程,就需要 updatedState 中转。需要回调变化就重启协程时,把回调放进 key 更直接。
原理流程
LaunchedEffect(Unit) 启动旧协程
→ 组合更新 → updatedState.value = 新回调
→ 协程定时读取 updatedState.value() → 调用最新回调
代码或图示
val currentOnSubmit by rememberUpdatedState(onSubmit)
LaunchedEffect(Unit) {
while (active) { delay(1000); currentOnSubmit() }
}
常见误区
- effect key 固定却直接捕获变化回调,回调停留在旧版本。
- 把高频变化对象整个放进 effect key,导致协程反复取消重启。
追问
- 何时该重启协程而非更新引用?答:依赖本身就是异步流程的输入(如选中 id),放进 key 重启;只是回调代理则用 updatedState。
- updatedState 初始值何时写入?答:每次组合执行时同步为当前值,首组合也有值。
07.1.1.7.1-055 保存大对象为什么不建议走 rememberSaveable?
一句话结论
保存容器面向小体积界面状态,大对象(列表、图片、树结构)序列化成本高、易超限丢失,应持久化到数据库/文件,界面只保存定位标识。
概念解释
配置变更与进程回收的保存通道容量有限且同步执行。保存大集合会拖慢重建、增大 Bundle 压力;恢复时还需反序列化。正确做法是保存 id 或查询条件,数据从本地缓存/数据库重建。
原理流程
大列表 / 位图 → 持久层(数据库 / 文件 / 内存缓存)
→ Saveable 只存 id、页码、选中项等小字段
代码或图示
val lastQuery = rememberSaveable { mutableStateOf("") }
// 列表数据在 ViewModel / 本地缓存中保留或重新加载
常见误区
- 把整页数据结构塞进 Saveable,旋转后恢复慢。
- 在 Saver 里做网络等待,恢复路径被异步阻塞。
追问
- 内存大对象跨重组保留放哪?答:ViewModel 或单例内存缓存;进程回收后从持久层重建。
- 如何判断保存状态超限?答:观察重建耗时、系统警告与恢复丢失现象,按分位数压测。
07.1.1.7.1-056 mutableStateOf 创建的状态对象有哪些类型接口?
一句话结论
返回 MutableState<T>,可读 .value 可写;只读视图为 State<T>,对外暴露只读接口,内部可变状态不外泄。
概念解释
State 是 Compose 可观察状态的基础接口,读取 value 建立订阅;MutableState 增加写入能力。State 可被收集为 Flow(snapshotFlow),也可与 StateFlow 桥接。
原理流程
mutableStateOf(initial) → MutableState<T>
→ 对外向下转型 State<T>(只读)
→ 读取订阅 / 写入通知
代码或图示
val count: MutableState<Int> = mutableStateOf(0)
val readonly: State<Int> = count
常见误区
- 把内部 MutableState 直接传给子组件,子组件可绕过事件回调改状态。
- 以为 State 等价于 StateFlow,二者桥接方式不同。
追问
- State 能在组合外观察吗?答:用 snapshotFlow 转 Flow;组合内直接读取订阅。
- 状态对象可以继承扩展吗?答:一般通过包装类持有 State 字段,而不是改接口实现。
07.1.1.7.1-057 mutableStateOf 的状态策略(policy)有什么作用?
一句话结论
mutableStateOf 可选状态策略控制初始值与相等判定行为,常见策略影响是否对集合做可观察包装;版本间 API 细节以官方文档为准(待确认)。
概念解释
状态策略决定写入时如何比较新旧值、是否触发通知。默认按 equals 判定,相等不重复通知。集合类型可选用可观察包装策略,使集合变更被追踪。具体策略枚举与构造参数版本差异需在目标 BOM 版本实测核对。
原理流程
写入新值
→ 策略比对新旧值
→ 相等:不通知
→ 不等:记录快照并通知订阅者
代码或图示
val list = mutableStateOf(listOf<Item>())
// 集合内容更新时替换为新不可变列表,而不是原地修改
常见误区
- 原地修改可变集合后依赖策略自动追踪元素级变化。
- 跨版本照搬策略参数名,未核对目标 BOM API。
追问
- 如何追踪集合变化最稳妥?答:使用不可变集合整体替换;元素级可观察需要对应可观察集合实现(以官方库提供为准)。
- 相等判定用 equals 还是引用?答:默认走 equals;特殊策略行为查目标版本文档确认。
07.1.1.7.1-058 Snapshot 快照机制如何追踪读取与写入?
一句话结论
快照为每次组合提供一致性视图:读取 State 时记录当前 group 为订阅者,写入时记录修改集合,提交后通知订阅者重算。
概念解释
快照系统把状态读写纳入事务追踪。读取建立依赖记录,写入进入修改记录;重组基于提交后的快照视图计算,避免组合中途看到半更新状态。读取追踪是 Compose 增量更新的基础。
原理流程
读取 state.value → 记录订阅(当前 group 依赖该 State)
写入 state.value → 进入快照修改记录
→ 事务提交 → 通知订阅 group
代码或图示
事务开始
→ 多次读写状态,视图保持一致
→ 提交:记录变更,通知订阅者
常见误区
- 认为读取追踪靠反射遍历对象字段,实际只追踪被包装的 State 读取点。
- 把快照理解成数据库事务回滚模型,它服务于界面一致性而非持久化。
追问
- 组合中途状态被谁修改?答:事件回调、Effect 与后台协程;主体内不应当场改写。
- 快照视图跨线程如何可见?答:线程各自读取当前快照;写入提交后新快照分发给订阅者,细节以官方快照文档为准。
07.1.1.7.1-059 快照事务(snapshot)在批量写入时如何保证一致性?
一句话结论
一个快照事务内的多次写入在提交时统一生效与通知,订阅者看到的是批量后的一致状态,不会逐次暴露中间值。
概念解释
snapshot { ... } 块内修改多个 State,提交前修改记录在事务内;提交后统一通知。界面重组基于一致的新视图,避免「第一个字段已改、第二个字段未改」的中间帧。
原理流程
snapshot {
stateA.value = ...
stateB.value = ...
}
→ 提交:批量记录变更 → 订阅者收到一致结果
代码或图示
snapshot {
form.name = newName
form.age = newAge
}
常见误区
- 以为分开两次赋值天然原子,跨线程时可能读到中间态。
- 在事务内启动异步任务并期待任务内写入属于同一事务。
追问
- 嵌套 snapshot 事务如何合并?答:内层事务并入外层修改记录,提交时机由外层控制;具体边界以官方实现为准。
- 批量写入与一次重组什么关系?答:订阅者按帧统一重组,中间值不产生独立界面帧。
07.1.1.7.1-060 快照回滚(rollback)用于什么场景?
一句话结论
未提交的快照修改可以回滚,常用于撤销临时改动、动画或事务试探;界面状态恢复到回滚前快照。
概念解释
快照记录可撤销集合,回滚丢弃本事务内修改。Compose 动画与内部状态管理会利用快照一致性;业务侧一般不直接操作底层回滚,更多理解其保证「失败改动不污染界面视图」。API 暴露程度随版本变化,标「待确认」时核对目标版本。
原理流程
事务内修改状态
→ 放弃提交 → 回滚修改记录
→ 订阅视图恢复旧快照
代码或图示
临时草稿改动 → 取消 → 恢复进入事务前的状态快照
常见误区
- 把快照回滚当成持久化撤销栈,它不保存历史版本给业务回退按钮。
- 在已提交通知后再试图回滚已生效的界面状态。
追问
- 业务撤销该用什么实现?答:在 ViewModel/状态容器中保存历史不可变副本,配合单向数据流。
- 哪些内部组件用到回滚?答:动画值、嵌套快照等框架内部机制,应用层通常只消费结果。
07.1.1.7.1-061 derivedStateOf 解决什么问题,什么时候必须用它?
一句话结论
它把多个 State 派生为一个收敛后的 State,只有派生结果真正变化时才通知下游;适合「输入高频变化但 UI 只在跨阈值时需要刷新」的场景。
概念解释
直接读取原始高频状态会让组件每次输入变化都重组;derivedStateOf 在内部比较派生值,结果未变不通知下游。典型:滚动位置判断是否显示回到顶部按钮、列表过滤后是否为空。
原理流程
原始 State 高频写入
→ derivedStateOf 计算派生值
→ 与上次派生值相等:不通知
→ 不等:更新派生 State,订阅者重组
代码或图示
val showTopButton by derivedStateOf {
scrollState.value > 0
}
常见误区
- 对每次输入都需要渲染的值也包 derivedStateOf,徒增一层比较。
- 派生结果返回可变集合新实例,每次都不等,收敛失效。
追问
- 它与 remember(依赖) 区别?答:remember 缓存计算结果但不阻断通知;derivedStateOf 是可观察 State,负责阈值收敛后再通知。
- 派生依赖哪些 State?答:lambda 内读取的 State 自动订阅,未读取的不纳入。
07.1.1.7.1-062 derivedStateOf 内部状态未达到阈值时如何避免下游重组?
一句话结论
内部缓存上次派生结果,每次重算先比对 equals,相等则不更新派生 State,下游订阅者收不到通知,从而跳过重组。
概念解释
派生 lambda 在依赖读取时执行,结果与缓存比对。相等时派生 State 值保持不变,订阅节点不被标记重组。不等才写入新值并通知。这要求派生结果是稳定可比较的类型。
原理流程
依赖变化 → 重算派生值
→ equals 与缓存相等 → 不通知下游
→ 不等 → 写派生 State → 通知订阅者
代码或图示
val canSubmit by derivedStateOf {
email.isNotBlank() && password.length >= 6
}
常见误区
- 派生结果返回每次新建的对象,equals 永远不等,收敛不生效。
- 在派生 lambda 里做副作用,收敛执行次数并不等于通知次数。
追问
- 结果是数据类如何保证比较?答:不可变数据类字段相等即可 equals 判定;可变引用不行。
- 多个 derivedStateOf 嵌套合理吗?答:可分层收敛,但避免过深嵌套导致排查困难。
07.1.1.7.1-063 snapshotFlow 如何把 Compose 状态桥接到 Flow?
一句话结论
snapshotFlow 把组合中读取的 State 转成冷 Flow,State 写入且派生值变化时发射最新快照值,适合把界面状态接入协程管道。
概念解释
Flow 收集时执行块并读取 State,建立快照订阅;值变化发射新值,初始值在收集时先发射一次。它与 collectAsState 方向相反:State 到 Flow,用于日志、副作用、状态联动而非直接渲染。
原理流程
flowCollection { snapshotState.value }
→ 读取建立订阅
→ 写入变化 → 发射新值
→ 离开收集 → 订阅解除
代码或图示
snapshotFlow { scrollState.firstVisibleItemIndex }
.distinctUntilChanged()
.collect { index -> trackScroll(index) }
常见误区
- 用 snapshotFlow 直接渲染界面,渲染应在组合主体读取 State。
- 忘记 distinctUntilChanged,重复相同值触发下游处理。
追问
- 初始值会发射吗?答:收集时先发射当前值,后续按变化发射。
- 多个 State 在块内读取如何合并?答:任一读取的 State 变化都会重新执行块并发射组合结果。
07.1.1.7.1-064 StateFlow 与 MutableState 之间如何互相转换与观察?
一句话结论
StateFlow 到 Compose 用 collectAsState() 转为 State 读取;Compose State 到 Flow 用 snapshotFlow;桥接在组合层完成,ViewModel 一般持有 Flow 或状态容器。
概念解释
ViewModel 暴露 StateFlow,界面 collectAsState 后在主体读取订阅。反向联动(界面状态驱动数据流)用 snapshotFlow 收集。不要在 ViewModel 直接持有 Compose MutableState,保持分层。
原理流程
ViewModel: StateFlow<UiState>
→ collectAsState() → State<UiState> → 组合读取
界面 MutableState → snapshotFlow → 协程管道
代码或图示
val uiState by viewModel.uiState.collectAsState()
常见误区
- 在 ViewModel 里 new mutableStateOf 供界面修改,破坏分层。
- 手动把 StateFlow 值拷贝进 MutableState 再双向同步,造成重复源。
追问
- collectAsState 初始值从哪来?答:StateFlow 当前值;无初始值的普通 Flow 用 produceState 包装。
- 桥接作用域如何取消?答:collectAsState 随组合离开取消;snapshotFlow 收集随协程取消解除。
07.1.1.7.1-065 快照状态的线程安全模型是什么?
一句话结论
快照 State 的读写由内部快照机制保证线程安全,可跨线程写入;但界面组合与节点操作仍在主线程,状态对象本身不是普通可变变量的同步替代。
概念解释
多线程读写 State 时,快照记录与通知有一致性保护。后台协程更新 State 后回到主线程刷新 UI。涉及共享可变业务数据时,仍需在 ViewModel/状态容器中用合适的并发约束。
原理流程
任意线程读写 State → 快照记录保护
→ 写入通知回主线程组合
→ 界面渲染在主线程完成
代码或图示
scope.launch(Dispatchers.IO) {
val result = query()
uiState.value = result // 跨线程写快照状态
}
常见误区
- 认为 State 可以替代所有锁,复杂业务聚合仍需线程安全容器。
- 在后台线程直接读 State 后操作平台 View。
追问
- 同时多线程写同一 State 会丢更新吗?答:快照模型保证写入记录,业务语义上的读-改-写仍需在单线程或原子结构中完成。
- 状态一致性窗口?答:事务内视图一致,提交后分发;细节以官方快照文档为准。
07.1.1.7.1-066 后台线程写入 SnapshotState 会通知主线程重组吗?
一句话结论
会。后台写入完成快照记录后,变更通知调度回主线程帧处理;界面重组不在后台线程执行。
概念解释
State 写入可发生在 IO 协程,通知机制把受影响 group 排到主线程组合阶段。若在后台线程直接持有 Compose 节点引用改属性,则不受快照保护。
原理流程
IO 线程写入 State
→ 快照记录变更
→ 主线程帧调度 → 订阅 group 重组
代码或图示
viewModelScope.launch(Dispatchers.IO) {
val data = load()
_uiState.value = UiState(data)
}
常见误区
- 期待后台线程立刻同步更新视图,实际刷新在后续主线程帧。
- 跨线程读取旧快照做判断,拿到的不是最新提交值。
追问
- 通知回主线程走什么机制?答:依赖 Compose 框架的帧调度;应用层不需要手动 post。
- 高频后台写入如何避免频繁重组?答:批量合并更新、收敛派生值、降频刷新。
07.1.1.7.1-067 状态通知的分发顺序与去重如何处理?
一句话结论
同一帧内批量变更统一分发,相等写入不产生通知;分发按组树顺序处理,业务逻辑不应依赖具体到达顺序。
概念解释
快照提交后通知订阅集合,相等值写入被策略跳过。多个 State 在同一事务变更时合并通知。顺序上框架按组合树处理,但组件之间应通过状态数据本身通信,而不是假设回调先后。
原理流程
事务提交 → 去重 / 相等过滤
→ 按树顺序通知订阅 group
→ 各自入队帧调度
代码或图示
state.value = state.value // 相等写入,不产生额外通知
常见误区
- 依赖两个订阅回调的先后顺序做状态联动。
- 同帧多次不同值写入,以为界面出现每一中间态。
追问
- 通知丢失怎么排查?答:先确认读取点在组合主体、State 是快照类型、值确实不等。
- 去重依据什么?答:策略默认 equals;集合引用替换触发通知,元素原地修改不触发。
07.1.1.7.1-068 produceState 如何把外部异步源包装成 Compose 状态?
一句话结论
produceState 在组合层启动协程订阅外部源(Flow、回调、定时器),把结果写入 State,离开组合自动取消订阅。
概念解释
它是桥接非 Compose 异步源的 Effect 式状态构造器:返回 State,协程块内收集外部数据更新 value;key 变化重启生产逻辑。适合一次性加载、传感器订阅、旧回调 API 接入。
原理流程
进入组合 → 启动 produceState 协程
→ 外部源回调 / 收集 → 更新 State.value
→ 离开组合 → 协程取消,订阅解除
代码或图示
val text by produceState("加载中") {
repository.load().collect { value = it }
}
常见误区
- 用 produceState 替代 ViewModel 持有业务状态,造成状态与界面生命周期耦合。
- 块内未处理取消,离开组合后回调仍更新已销毁节点。
追问
- 与 collectAsState 区别?答:collectAsState 直接桥接 Flow;produceState 面向任意异步源并可自定义初始值与转换。
- key 变化行为?答:取消旧协程,以新 key 重新执行生产块。
07.1.1.7.1-069 StateObject 与自动可观察(autoboxed State)是什么关系?
一句话结论
StateObject 是框架内部可观察状态对象接口,mutableStateOf 返回的实现属于这一体系;应用层通常只面对 State/MutableState 接口,不直接实现 StateObject。
概念解释
编译器与运行时通过可观察对象体系识别状态读写。自动装箱指基本类型 State 有专门实现以避免装箱开销。应用层自定义可观察性应通过组合现有 State 字段,而不是手写内部接口。版本间内部接口名与实现细节以官方源码为准(待确认)。
原理流程
mutableStateOf → 框架可观察 State 实现
→ 读取追踪 / 写入通知由内部对象完成
代码或图示
val count = mutableStateOf(0) // 内部为可观察状态实现
常见误区
- 应用层试图继承内部 State 实现类,版本升级易失效。
- 把普通对象包一层 StateObject 期待字段级可观察。
追问
- 基本类型有性能优化吗?答:框架对 Int、Boolean 等提供专用 State 实现减少装箱,具体以运行时源码为准。
- 自定义可观察组件怎么做?答:暴露 MutableState 字段或使用不可变状态数据类。
07.1.1.7.1-070 嵌套状态对象(State 内字段)如何被追踪?
一句话结论
只有被包装成 State 的字段在读取时被追踪;普通嵌套字段变化不通知。需要字段级观察就把字段声明为 State,或整体替换父级不可变对象。
概念解释
class Holder(val state: MutableState<Int>) 读取 holder.state.value 可追踪;holder.name = x 普通字段修改不产生通知。嵌套结构要做元素级可观察,需在每层使用可观察包装,否则用不可变数据类整体 copy。
原理流程
holder.state.value 读取 → 订阅该 State
holder.name = newName → 普通写入,无通知
父对象整体替换为新副本 → 父 State 通知
代码或图示
class Form {
val email = mutableStateOf("") // 字段级可观察
}
常见误区
- 数据类字段 var 可变,以为整体 State 会追踪字段改动。
- 嵌套列表原地 add 后期待界面刷新。
追问
- 状态树怎么设计更稳?答:界面状态用不可变数据类 + 整体替换;少量高频交互字段可 State 包装。
- 读取嵌套 State 订阅归属?答:归属读取该字段 State 的 group。
07.1.1.7.1-071 快照记录(modified record)在重组中的作用是什么?
一句话结论
快照记录保存本事务内被修改的 State 集合,提交后据此通知订阅者;它让重组只处理真正变化的状态,而不是全树扫描。
概念解释
写入不是直接遍历所有节点,而是先登记到修改记录。提交时框架根据记录反查订阅 group,把它们标记为重组候选。记录也支撑批量合并与相等过滤。
原理流程
写入 State → 登记 modified record
→ 提交 → 按记录找订阅 group
→ 标记重组候选 → 帧调度执行
代码或图示
record: [StateA, StateC]
→ 订阅集合: A→[G1], C→[G3]
→ 通知 G1、G3
常见误区
- 以为每次写入都全量遍历组合树找订阅者。
- 手动维护订阅列表替代快照记录,方向错误。
追问
- 相等写入会进记录吗?答:策略判定相等则不登记有效变更。
- 记录在何时清空?答:事务提交通知后进入下一快照周期;内部实现细节以运行时源码为准。
07.1.1.7.1-072 为什么不可变集合(List)作为状态能被正确追踪?
一句话结论
不可变集合每次更新都产生新引用与新内容快照,整体替换 State 时 equals 与引用可判定;原地修改可变集合无法产生可追踪的变更信号。
概念解释
Compose 追踪的是 State 写入与替换,不是集合内部元素。不可变集合(或复制后替换引用)让「内容变化」体现为新 State 值,下游可比较相等。可变 List 原地 add 不产生 State 写入,界面不刷新。
原理流程
不可变:list + item → 新 List → State.value = 新 List → 通知
可变:list.add(item) → 无 State 写入 → 不通知
代码或图示
items.value = items.value + newItem // 整体替换
常见误区
- 用
mutableStateOf(mutableListOf())后原地增删,期待列表刷新。 - 把只读
List<>当作不可变保证,Kotlin 只读接口仍可能被实现类修改。
追问
- 元素级观察有现成方案吗?答:可观察集合实现或不可变集合整体替换;第三方不可变集合库按项目技术栈选型。
- 集合相等如何判定?答:列表顺序与内容 equals;顺序敏感,重排会判为不等。
07.1.1.7.1-073 状态在组合期间被读取后订阅,离开组合时如何取消订阅?
一句话结论
group 离开组合时,上下文自动解除该 group 登记的全部状态订阅,不需要手动反注册;Effect 注册的外部监听则需在 onDispose 中释放。
概念解释
快照订阅随组合 group 生命周期管理:进入登记、离开解除。手动注册的平台回调、Flow 收集不属于快照订阅,必须在 DisposableEffect.onDispose 里取消,避免泄漏。
原理流程
组合读取 State → 登记到 group 订阅表
→ group 离开组合 → 自动解除快照订阅
→ 外部订阅:onDispose 中手动 cancel / 反注册
代码或图示
DisposableEffect(Unit) {
val sub = flow.collect { ... }
onDispose { sub.cancel() }
}
常见误区
- 以为 State 订阅也需要手动 removeListener,框架自动管理。
- 离开组合后外部 Flow 仍在回调更新旧节点引用。
追问
- 订阅解除在什么线程执行?答:随组合离开流程在主线程处理;外部回调释放动作按其 API 线程要求执行。
- 节点保留但订阅先解除可能吗?答:结构错位、group 被移除时订阅随 group 回收。
07.1.1.7.1-074 snapshotFlow 的初值与首次发射时机如何确定?
一句话结论
Flow 被收集时先执行读取块得到当前快照值并发射,之后每次被读取的 State 变化且结果不等时再次发射。
概念解释
snapshotFlow 是冷 Flow,没有收集者就不读取状态。收集起始时刻执行一次块,把当前值作为首个元素;初始值不是缓存的历史值。连续相同值可叠加 distinctUntilChanged 过滤。
原理流程
collect 开始 → 执行块读取 State → 发射当前值
→ State 变化 → 重执行块 → 结果不等则发射
代码或图示
snapshotFlow { uiState.index }
.distinctUntilChanged()
.collect { ... }
常见误区
- 以为未收集时 Flow 已持有初始状态。
- 忘记去重,相同 index 重复触发埋点。
追问
- 块内读取多个 State 会怎样?答:任一变化都重执行块,发射组合后的当前结果。
- 收集取消时订阅何时解除?答:协程取消后快照订阅解除。
07.1.1.7.1-075 快照状态与 ViewModel 持有状态的分工边界是什么?
一句话结论
ViewModel 持有跨界面存活、可测试的业务状态(通常 Flow/状态容器);Compose State 持有纯界面临时状态(输入草稿、展开态、动画值)。
概念解释
业务数据、加载状态、交互结果归 ViewModel,配置变更不丢失且便于测试;remember/Saveable 管理界面局部状态。跨页面共享的状态不放在可组合项内部,避免随组合销毁。
原理流程
业务状态:ViewModel → StateFlow → collectAsState 进入组合
界面临时状态:remember / rememberSaveable 留在组合层
代码或图示
// ViewModel: val uiState: StateFlow<UiState>
// Composable: val uiState by vm.uiState.collectAsState()
// 本地:val expanded = remember { mutableStateOf(false) }
常见误区
- 把业务列表状态存在 remember,旋转后丢失。
- 在 ViewModel 里直接持有 Compose MutableState,耦合渲染层。
追问
- 状态拿不准归谁?答:离开当前页面是否还要保留、是否需要单元测试,是主要判断依据。
- 进程回收后两边分别怎么恢复?答:ViewModel 从持久层重载,Saveable 恢复小界面状态。
07.1.1.7.1-076 状态提升(state hoisting)的定义与收益是什么?
一句话结论
把组件内部状态上移到父级,组件改为接收状态参数与事件回调;收益是状态可复用、可测试、可控,组件变成无状态展示单元。
概念解释
未提升的组件内部持有状态,外部无法控制;提升后状态来源与变更路径显式化,同一组件可在不同父级演示不同状态,也便于测试断言。提升不是越多越好,局部临时状态留在组件内部更简单。
原理流程
内部状态组件
→ 提升:状态上移,参数 + 回调下发
→ 父级持有唯一数据源,子组件纯展示
代码或图示
@Composable
fun SearchBar(query: String, onQueryChange: (String) -> Unit) {
TextField(value = query, onValueChange = onQueryChange)
}
常见误区
- 为提升而提升,把展开态这类纯局部状态也上提到 ViewModel。
- 提升后仍在子组件内部副本改状态,形成双数据源。
追问
- 提升到哪一层?答:到第一个需要读取或控制该状态的祖先,共享需求更高时到 ViewModel。
- 无状态组件有什么测试优势?答:直接传不同参数验证渲染,回调断言事件,无需构造内部环境。
07.1.1.7.1-077 单向数据流在 Compose 界面层如何落地?
一句话结论
状态自上而下作为参数流动,事件自下而上通过回调上报,父级更新状态后再次下发;界面不反向写入父级状态对象。
概念解释
UDF 保证状态变化路径可预测:子组件只通过回调表达意图,父级或 ViewModel 决定是否更新。渲染函数基于当前状态纯计算,副作用通过 Effect 触发。
原理流程
State → 参数 → 子组件渲染
子组件 → onEvent 回调 → 父级更新 State → 重新下发
代码或图示
Counter(count = uiState.count, onIncrement = { vm.inc() })
常见误区
- 子组件拿到可变 State 直接写入,绕过事件回调。
- 状态沿多层逐层透传却不提升到共享祖先,链路冗长。
追问
- UDF 与单向绑定区别?答:Compose 以参数与回调函数实现,不需要观察者注册框架;Flow 桥接发生在状态容器与组合层之间。
- 事件回调命名约定?答:onXxx 表达意图,参数携带事件数据。
07.1.1.7.1-078 提升到可组合项参数与提升到 ViewModel 如何选择?
一句话结论
只在当前界面内使用、随页面退出可丢弃的状态提升到父级可组合项;跨页面存活、需要业务逻辑或测试的状态提升到 ViewModel。
概念解释
组合层状态跟随 Composition 生命周期;ViewModel 跟随界面作用域存活配置变更。共享状态、加载结果、表单提交状态归属 ViewModel;展开折叠、选中高亮、本地草稿归属组合层或父组件。
原理流程
仅本页交互 → 父 Composable 持有 remember
跨页共享 / 业务规则 / 测试 → ViewModel 持有
代码或图示
// 父级组合持有:val selected = remember { mutableStateOf(...) }
// ViewModel 持有:val uiState = MutableStateFlow(UiState())
常见误区
- 所有状态都塞 ViewModel,造成状态容器臃肿。
- 业务状态留在组件内部,配置变更后丢失。
追问
- 父级组合持有状态会在导航返回后保留吗?答:取决于组合树是否保留;离开组合即回收。
- 两者之间需要桥接吗?答:ViewModel 暴露 Flow,组合层 collectAsState 接收,单向流动。
07.1.1.7.1-079 受控组件与非受控组件在 Compose 中如何区分?
一句话结论
状态由外部传入并通过回调更新的是受控组件;内部 remember 自管状态的是非受控组件;同一组件可同时提供两种用法。
概念解释
受控:value 与 onValueChange 都来自父级,外部完全控制显示;非受控:内部 rememberSaveable 维护初始状态,父级只给初值。表单输入、开关等组件常提供两套重载。
原理流程
受控:props(state, event) → 父级决定状态
非受控:内部 remember 初值 → 组件自更新
代码或图示
// 受控
TextField(value = query, onValueChange = { vm.setQuery(it) })
// 非受控:内部持有 rememberSaveable 草稿
常见误区
- 同时传外部 value 与内部副本,两处状态不一致。
- 非受控组件把内部状态暴露给外部读写,破坏封装。
追问
- 什么时候用受控?答:需要父级校验、重置、提交、跨组件同步时。
- 非受控适合什么?答:纯展示型临时交互,离开页面可丢弃的状态。
07.1.1.7.1-080 状态提升后,子组件通过什么接口回传事件?
一句话结论
通过 onXxx 回调 lambda 参数回传意图与数据,不直接持有父级状态引用;回调由父级决定调用状态更新逻辑。
概念解释
接口形态是函数类型参数,如 onSelect(item)、onValueChange(text)。子组件在点击、输入等时机调用回调,事件数据作为参数传入。父级把回调接到 ViewModel 方法或本地状态更新。
原理流程
子组件交互 → 调用 onXxx(data)
→ 父级回调实现 → 更新状态 / 调用业务方法
代码或图示
@Composable
fun UserRow(name: String, onClick: () -> Unit) {
Row(onClick = onClick) { Text(name) }
}
常见误区
- 回调参数携带可变对象引用,子组件可被外部反向修改。
- 回调命名成 setter 风格,模糊「意图上报」与「直接赋值」的边界。
追问
- 回调稳定性怎么保证?答:父级侧记住稳定实现或捕获不可变参数;捕获可变引用会使 lambda 不稳定。
- 多个事件如何组织?答:按意图拆分 onXxx,避免一个万能回调携带一堆标志位。
07.1.1.7.1-081 父组件参数变化时,子组件内部状态如何保持与重置?
一句话结论
内部 remember 默认跨重组保留;需要在外部参数变化时重置内部状态,用 rememberSaveable/remember 的 key 绑定外部参数,参数变化触发槽位重建。
概念解释
子组件内部状态不随父级每次重组清空。但当外部初始条件变化(如切换到另一条目),需要把内部草稿重置为对应初值:以外部 id 为 remember key,或用 LaunchedEffect(参数) 同步内部状态。
原理流程
参数不变 → 内部状态保留
参数变化 → remember(key) 重算 / Effect 同步内部值
代码或图示
val draft = remember(item.id) { mutableStateOf(item.title) }
常见误区
- 切换条目后内部旧草稿残留,串到新条目。
- 每次重组都用参数覆盖内部状态,用户输入被打断。
追问
- 受控输入与内部草稿如何同步?答:外部值变化时通过 Effect 重置草稿;编辑过程中草稿内部持有。
- key 重置会触发什么副作用?答:关联的 DisposableEffect(key) 先 onDispose 再重建订阅。
07.1.1.7.1-082 什么情况下状态应该保留在可组合项内部而非提升?
一句话结论
状态只服务于该组件的展示细节、不被其他组件读取、离开页面可丢弃时,留在内部 remember 更简单;需要外部控制或复用时才提升。
概念解释
展开/折叠、本地 hover 态、动画中间值、组件内部滚动位置等属于局部界面状态。提升会增加参数与回调链路,收益有限。判断标准:其他祖先或兄弟组件是否需要读取该状态。
原理流程
仅本组件使用 → 内部 remember
兄弟组件 / 父级需要 → 提升
跨页面 / 业务规则 → ViewModel
代码或图示
val expanded = remember { mutableStateOf(false) }
常见误区
- 把纯动画态上提到 ViewModel,造成状态容器与 UI 细节耦合。
- 兄弟组件需要同步时仍藏在内部,只能靠反查或全局变量。
追问
- 内部状态需要配置变更存活怎么办?答:rememberSaveable;仍不满足则提升持久层。
- 内部状态难以测试怎么办?答:若行为复杂,说明它已不是纯展示细节,应提升出可测试逻辑。
07.1.1.7.1-083 单一数据源在界面树中如何确定归属?
一句话结论
状态归属第一个需要读取它的共同祖先;更全局的状态归 ViewModel,避免同一状态在多层各自副本。
概念解释
单一数据源(SSOT)要求状态只在一处持有,其他位置通过参数或派生读取。归属过高会让无关组件依赖,归属过低会被兄弟组件重复复制。先画读取组件集合,取最小公共祖先。
原理流程
列出读取状态的组件
→ 找最小共同祖先
→ 状态在该层持有,向下传参
代码或图示
A、B 同属 P 子树 → 状态归 P
跨页面 → ViewModel
常见误区
- 父级与子组件各存一份镜像状态,靠回调同步。
- 状态放在深层叶子,兄弟组件需要时只能向上冒泡事件。
追问
- 派生数据算第二个源吗?答:不算,派生值由 SSOT 计算得到,不单独写入。
- 缓存视图状态与业务源如何区分?答:缓存是视图副本,源仍是业务状态,刷新时从源重建。
07.1.1.7.1-084 状态提升对可测试性有什么影响?
一句话结论
提升后的组件接收纯参数与回调,测试时可构造任意状态断言渲染、捕获回调断言事件,不依赖组合环境与内部状态。
概念解释
无状态展示组件接近纯函数:给定输入验证输出;事件回调可用假实现捕获参数。内部 remember 状态需要在测试环境触发交互才能到达目标状态,路径更长。业务逻辑在 ViewModel 中可脱离 UI 单测。
原理流程
测试输入参数 → 断言节点文本 / 图标状态
→ 触发操作 → 捕获 onXxx 回调参数
代码或图示
composeTestRule.setContent {
ProfileCard(name = "Ann", onClick = { captured = it })
}
常见误区
- 把可测试逻辑留在组件内部,只能靠 instrumentation 测试覆盖。
- 提升后仍在组件内 new 业务依赖,测试替换困难。
追问
- Compose 测试如何断言回调?答:在 setContent 中传入记录 lambda,点击节点后检查捕获值。
- 状态容器测试放哪?答:ViewModel/状态容器用 JVM 单测,不启动组合。
07.1.1.7.1-085 多个子组件共享状态时,提升层级放在哪一层?
一句话结论
提升到这些子组件的最小共同父级;若状态还需跨页面或参与业务规则,提升到 ViewModel;不要在兄弟组件间直接互相引用。
概念解释
共享状态在共同祖先持有,通过参数下发,事件回调上报。层级过低无法覆盖全部使用者,过高则无关组件被迫依赖。导航级共享由 ViewModel 或作用域状态容器管理。
原理流程
兄弟组件 C1、C2 需要同一状态
→ 共同父 P 持有 → 参数分别下发
→ 跨页面 → 共享 ViewModel / 状态存储
代码或图示
val selected = remember { mutableStateOf<Item?>(null) }
MasterList(selected, onSelect = { selected.value = it })
DetailPanel(selected.value)
常见误区
- 兄弟组件通过外部单例互发状态,绕过祖先层级。
- 状态在每个兄弟内部各存一份,靠事件同步。
追问
- 祖先层级很高且无关组件很多怎么办?答:用 CompositionLocal 局部注入,或拆分子树容器持有状态。
- 共享状态需要持久化?答:归 ViewModel/持久层,组合层只接收当前快照。
07.1.1.7.1-086 CompositionLocal 解决什么问题,为什么不逐层传参?
一句话结论
CompositionLocal 让值沿组合树层级向下隐式传递,避免深层组件逐层透传相同参数(如主题、上下文、本地配置)。
概念解释
某些值(颜色方案、字体、本地语言、上下文)在多个层级复用,逐一层层加参数会污染每个中间组件接口。CompositionLocal 在作用域内 provide 值,深层组件读取 current 即可。它是隐式依赖,使用时要权衡可追踪性。
原理流程
祖先 CompositionLocalProvider(LocalX provides value)
→ 子树任意位置读取 LocalX.current
代码或图示
CompositionLocalProvider(LocalTheme provides darkTheme) {
AppRoot()
}
常见误区
- 用 CompositionLocal 传普通业务状态,依赖来源难以追踪。
- 跨多个不相关子树共享可变业务数据,破坏显式参数链路。
追问
- 与依赖注入容器区别?答:CompositionLocal 是组合树内的局部作用域注入,随组合层级生效;全局 DI 另属框架层。
- 默认值何时使用?答:作用域外读取返回 CompositionLocal 定义的默认值。
07.1.1.7.1-087 CompositionLocal 的 provide 作用域如何向下继承?
一句话结论
CompositionLocalProvider 包裹的子树读取到 provided 值;离开该作用域恢复上层值或默认值,层级覆盖遵循就近原则。
概念解释
provide 形成作用域边界:内层 provider 可覆盖外层值。兄弟 provider 互不影响。值沿组合树向下查找,不向上冒泡。局部值变化时,读取点订阅并重组。
原理流程
Provider A(value=1)
→ Provider B(value=2) 子树读到 2
→ B 之外读到 1
→ 无 provider 读到默认值
代码或图示
CompositionLocalProvider(LocalColorScheme provides light) {
CompositionLocalProvider(LocalColorScheme provides dark) {
Overlay() // 读到 dark
}
}
常见误区
- 以为 provide 值对整棵全局树生效,实际只影响包裹子树。
- 在兄弟节点 provider 之间期待值互相可见。
追问
- 作用域与导航返回如何恢复?答:离开 provider 子树后读取上层/默认值。
- 多个 local 能否一次提供?答:Provider 可并列传入多个 local-value 对。
07.1.1.7.1-088 如何自定义一个类型安全的 CompositionLocal?
一句话结论
用 staticCompositionLocalOf 或 compositionLocalOf 声明泛型本地实例,提供默认值或工厂,再在祖先 Provider 中提供、深层读取 current。
概念解释
声明时指定类型与默认值;staticCompositionLocalOf 在值变化时不单独追踪读取点(整作用域更新),compositionLocalOf 支持精确读取订阅。按值变化频率与精度选择,版本 API 细节以官方文档为准。
原理流程
val LocalProfile = compositionLocalOf<Profile> { error("未提供 Profile") }
// 提供:CompositionLocalProvider(LocalProfile provides profile) { ... }
// 读取:val profile = LocalProfile.current
代码或图示
val LocalAppTheme = staticCompositionLocalOf<AppTheme> { AppTheme.Light }
常见误区
- 默认值给 null 而读取点不判空,作用域外崩溃。
- 值高频变化却选 staticCompositionLocalOf,作用域整体重建。
追问
- 两种 local 选择依据?答:值基本不变用 static;值会切换且只需读取点刷新用可追踪版本。
- 类型缺失如何编译期发现?答:泛型参数固定类型,读取点 current 带类型。
07.1.1.7.1-089 CompositionLocal.current 在组合中读取如何参与重组?
一句话结论
在组合主体读取 .current 时登记对该局部值的订阅;值变化后读取点重组,前提是使用可追踪的 compositionLocalOf。
概念解释
读取行为与 State 读取类似,发生在组合执行路径上。Effect/回调里读 current 不订阅。static 版本的更新粒度不同:值变化时影响提供作用域内相关读取,精确行为以框架实现为准。
原理流程
组合主体读取 LocalX.current → 登记订阅
→ provide 值变化 → 读取点重组
代码或图示
val scheme = LocalColorScheme.current
Text("主题", color = scheme.primary)
常见误区
- 在回调里读 current 并期待局部值变化触发刷新。
- 把 current 结果缓存进 remember 却不把 local 值加入 key。
追问
- 缓存派生对象依赖主题怎么办?答:把 scheme 加入 remember key,主题切换重算。
- 局部值不稳定会影响跳过吗?答:读取参与订阅,值类型稳定性同样影响节点跳过判定。
07.1.1.7.1-090 使用 CompositionLocal 有哪些代价与反模式?
一句话结论
代价是依赖隐式、链路不直观、调试定位难;反模式包括传递普通业务状态、多层覆盖导致值来源混乱、作用域外读取默认值。
概念解释
CompositionLocal 适合贯穿整树的环境型值。业务状态、可枚举的组件依赖应走显式参数。混用会让组件行为取决于外层是否 provider,测试与复用困难。
原理流程
环境型值(主题 / 字体 / 上下文)→ CompositionLocal
业务状态 / 组件依赖 → 显式参数
代码或图示
反例:LocalUserId 传登录态业务状态
正例:LocalColorScheme 传主题颜色方案
常见误区
- 一个 local 塞多个不相关值,作用域语义模糊。
- 不在文档中标注必需 provider,组件脱离作用域即用默认值出错。
追问
- 如何降低隐式代价?答:命名清晰、默认值报错或兜底、限制 local 数量、在组件入口注释依赖的 local。
- 调试时如何找 provider 位置?答:Inspector 查看组合树层级与提供作用域,或在读取点打断点观察 current 来源。
07.1.1.7.1-091 LaunchedEffect、DisposableEffect、SideEffect 三者如何选型?
一句话结论
需要在组合作用域内启动协程异步流选 LaunchedEffect;需要创建/释放可清理资源选 DisposableEffect;需要把组合状态同步到非 Compose 对象选 SideEffect。
概念解释
LaunchedEffect 提供协程作用域,key 变化重启;DisposableEffect 提供 onDispose 清理钩子;SideEffect 在每次成功重组后执行,用于向外同步,不持有可释放资源。三者都在组合生命周期内受控执行。
原理流程
异步任务 / 收集 Flow → LaunchedEffect
注册监听 / 订阅 → DisposableEffect(onDispose 反注册)
同步到外部对象 → SideEffect
代码或图示
LaunchedEffect(key) { /* coroutine */ }
DisposableEffect(key) { val s = reg(); onDispose { s.cancel() } }
SideEffect { external.set(state) }
常见误区
- 用 SideEffect 注册监听却不反注册。
- 把一次性加载放进 SideEffect,每次重组重复执行。
- 在 DisposableEffect 里启动长期协程而不用对应作用域取消。
追问
- 哪个 effect 在离开组合时保证清理?答:DisposableEffect.onDispose;LaunchedEffect 协程随作用域取消。
- 三者执行顺序?答:按组合执行顺序在对应生命周期阶段运行,不要依赖跨 effect 的精确先后。
07.1.1.7.1-092 LaunchedEffect 的 key 变化时旧协程如何处理?
一句话结论
key 变化时旧协程被取消,Effect 块以新 key 重新启动;key 不变则协程持续运行,离开组合时取消。
概念解释
LaunchedEffect 的 key 列表标识异步任务依赖。任何 key 与上次不等,框架取消旧协程并重新执行块。key 为 Unit 时只在进入组合启动一次。取消遵循协程结构化并发,子任务一并取消。
原理流程
进入组合 → 启动协程 A(key=k1)
→ key 变 k2 → 取消 A → 启动协程 B
→ 离开组合 → 取消当前协程
代码或图示
LaunchedEffect(selectedId) {
val detail = api.load(selectedId)
detailState.value = detail
}
常见误区
- key 传入不稳定对象,频繁不等导致协程反复重启。
- 在协程内做不可取消的阻塞操作,取消时不能及时响应。
追问
- 旧协程取消时 finally 会执行吗?答:协程取消走取消异常,finally/invokeOnCompletion 可做收尾。
- 只想刷新数据不重启流程怎么办?答:用 rememberUpdatedState 包装回调,或在协程内监听 Flow 变化。
07.1.1.7.1-093 DisposableEffect 的 onDispose 在什么时机回调?
一句话结论
key 变化旧组离开时、group 离开组合时、Composition 释放时调用 onDispose,用于反注册与释放资源。
概念解释
DisposableEffect 在进入组合时建立资源,onDispose 是清理钩子。触发时机包括:key 变化先清理旧效果再建新效果;分支消失;导航退出;宿主释放。清理代码必须幂等,避免重复释放。
原理流程
进入组合 → 注册资源
→ key 变化 / 离开组合 / 释放 → onDispose → 反注册
代码或图示
DisposableEffect(Unit) {
val listener = register()
onDispose { listener.remove() }
}
常见误区
- 在 onDispose 里读已失效的外部对象引用而不判空。
- 资源创建放在 effect 块外,清理时找不到对应实例。
追问
- onDispose 在配置变更时一定调用吗?答:组合保留时不调用;组合重建或 key 变化时按离开路径触发,具体以宿主行为实测为准。
- 清理失败如何排查?答:在 onDispose 打日志,结合节点树离开时机定位。
07.1.1.7.1-094 SideEffect 与普通 remember 初始化块有何区别?
一句话结论
SideEffect 在每次重组成功后执行,用于把状态同步给非 Compose 代码;remember 工厂只在槽位首次分配(或 key 变化)时执行,用于构造本地对象。
概念解释
SideEffect 没有清理钩子,执行频率跟随重组;它适合日志上报、外部对象刷新。remember 工厂是惰性构造,不承担对外同步职责。需要资源释放仍用 DisposableEffect。
原理流程
remember:首次 / key 变化执行一次 → 缓存对象
SideEffect:每次重组后执行 → 同步外部世界
代码或图示
SideEffect {
analytics.setCurrentScreen(screenName)
}
常见误区
- 把初始化注册监听放进 SideEffect,重复执行且不释放。
- 用 remember 工厂做状态对外同步,重组后不刷新。
追问
- SideEffect 每次重组都跑会不会重复上报?答:需在内部比对上次值再决定是否同步,或改用 Effect + key。
- 与 LaunchedEffect 区别?答:SideEffect 同步执行无协程;异步等待、流收集用 LaunchedEffect。
07.1.1.7.1-095 副作用为什么不能直接写在可组合项主体里?
一句话结论
组合主体可能被重复执行、跳过或重放,直接写副作用会导致重复请求、重复注册与不确定状态;副作用必须放进受控的 Effect 回调。
概念解释
主体是当前状态到界面的纯计算视图。重组次数不受业务控制,调试与配置变更还可能多次进入。写库、发请求、注册监听、改外部对象等副作用放在主体里会随重放重复发生。
原理流程
主体:只读状态 → 描述界面
→ 副作用:Effect(按 key / 生命周期精确触发)
代码或图示
// 错误:主体直接请求
ViewModel.load()
// 正确
LaunchedEffect(Unit) { ViewModel.load() }
常见误区
- 以为主体只执行一次,把初始化逻辑写在里面。
- 在主体里修改传入对象字段,破坏纯计算约定。
追问
- 构造纯对象可以放主体吗?答:无副作用的对象构造可接受;有资源获取、注册行为的仍走 Effect。
- 编译器能拦这类问题吗?答:不能完全拦截,需靠代码审查与 Effect 规范。
07.1.1.7.1-096 监听注册与反注册应该用哪个 Effect 完成?
一句话结论
用 DisposableEffect:进入组合注册监听,onDispose 中反注册;key 变化时先释放旧监听再注册新监听。
概念解释
监听器、广播、Flow 收集、平台回调都持有资源引用,必须成对释放。DisposableEffect 的清理钩子正好对应注册生命周期。协程式收集也可放 LaunchedEffect,随作用域取消;需要显式反注册 API 时用 DisposableEffect。
原理流程
DisposableEffect(dependency)
→ 注册 listener / 订阅
→ onDispose → remove / cancel
代码或图示
DisposableEffect(lifecycleOwner) {
val observer = lifecycleObserver()
lifecycleOwner.lifecycle.addObserver(observer)
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}
常见误区
- 注册放主体、反注册忘记写。
- key 变化时旧监听未移除,多个监听叠加回调。
追问
- Flow 收集放哪个?答:LaunchedEffect 中 collect 随协程取消;需要显式 Subscription 管理时可 DisposableEffect 配合。
- 反注册顺序有要求吗?答:按资源依赖逆序释放,避免回调访问已清理对象。
07.1.1.7.1-097 @Stable 与 @Immutable 注解分别声明什么,编译器如何使用?
一句话结论
@Immutable 声明类型实例创建后永不可变;@Stable 声明类型对外表现稳定(可变但变化可被观察);编译器据此判断参数稳定性以决定能否跳过重组。
概念解释
注解是给编译器的稳定性契约。@Immutable 字段全部不可变;@Stable 允许内部可变,但状态变化必须通过可观察机制反映。编译器依赖契约做跳过推导,错误标注会破坏跳过保证。
原理流程
参数类型 → 稳定性推导(字段 / 注解 / 集合可变性)
→ 稳定:equals 未变可跳过
→ 不稳定:保守不跳过
代码或图示
@Immutable
data class UiText(val value: String)
@Stable
interface ButtonState { /* 实现保证可观察 */ }
常见误区
- 给含可变字段且无观察机制的类标 @Stable,承诺不成立。
- 以为注解只影响文档,实际直接影响重组跳过。
追问
- 注解标错会有什么后果?答:不稳定被标稳定可能跳过后界面不刷新;稳定被当不稳定则过度重组。
- 集合类型默认稳定吗?答:Kotlin 只读集合在 Compose 视角默认不稳定,需不可变包装或注解说明。
07.1.1.7.1-098 可组合项参数不稳定时,为什么无法被跳过重组?
一句话结论
编译器无法证明不稳定参数在两次重组间相等,保守判定节点不可跳过,每次父级重组都重新执行函数体。
概念解释
跳过需要比较参数是否相等。不稳定类型可能在两次调用间被原地修改,equals 不能代表界面输入未变。为避免漏刷新,编译器不生成跳过分支。lambda 闭包捕获可变引用、可变集合、未标注的自定义类都属此类。
原理流程
参数类型不稳定
→ 无法证明 equals 等价于未变化
→ 不生成跳过检查 → 每次重调
代码或图示
// 反例:可变集合参数
@Composable
fun Bad(list: MutableList<Item>) { /* 不可跳过 */ }
常见误区
- 以为传同一引用就一定跳过,类型不稳定时引用相等也不跳过。
- 把不稳定参数包一层 data class 却仍含不稳定字段。
追问
- 如何让参数稳定?答:不可变数据类、不可变集合、稳定 lambda、@Immutable/@Stable 契约。
- 不可跳过节点性能影响?答:高频重组下函数体与子树反复执行,需要拆参或稳定化。
07.1.1.7.1-099 lambda 表达式在什么条件下被编译器视为稳定?
一句话结论
lambda 未捕获可变状态、捕获值均稳定时可被视为稳定;捕获可变引用、捕获不稳定对象或依赖可变外部状态时 lambda 不稳定。
概念解释
lambda 稳定性看闭包捕获。无捕获 lambda 天然稳定;捕获稳定不可变参数也稳定。捕获 Activity、可变集合、可变 var 会让 lambda 成为不稳定参数,影响节点跳过。父级可 remember 稳定回调减少重建。
原理流程
lambda 捕获集合 → 逐项检查稳定性
→ 全部稳定 / 无捕获 → lambda 稳定
→ 捕获可变引用 → 不稳定
代码或图示
val onClick = remember(item.id) {
{ viewModel.select(item.id) }
}
常见误区
- lambda 每次重组新建导致子组件无法跳过,却不归因于捕获不稳定。
- 在 lambda 里读可变外部 var,闭包绑定旧值且不稳定。
追问
- 回调需要拿最新值怎么办?答:rememberUpdatedState 包装,或把稳定依赖放入 remember key。
- 函数引用(::method)稳定性如何?答:未绑定可变实例时较稳定;绑定可变对象仍看接收者稳定性。
07.1.1.7.1-100 判定一个类型稳定与否的编译器规则有哪些?
一句话结论
规则覆盖:基本类型与字符串稳定;不可变字段的类可推导稳定;可变字段、可变集合、未标注自定义类型、泛型未约束类型按不稳定处理;注解可覆盖契约。
概念解释
编译器逐字段检查类型可变性与可见性。只读集合接口不等于实现不可变;自定义类字段含 var 或不稳定类型则整体不稳定;@Immutable/@Stable 显式声明契约;泛型参数若未标 @Stable 边界,实例类型按保守规则处理。
原理流程
类型 → 字段遍历
→ 基本类型 / 不可变引用 → 稳定候选
→ var 字段 / 可变集合 / 未知泛型 → 不稳定
→ 注解契约 → 按声明处理
代码或图示
@Immutable
data class Profile(val name: String, val tags: List<String>)
常见误区
- data class 一律视为稳定,实际取决于字段可变性。
- 忽略泛型实参稳定性,容器稳定但元素不稳定导致整体不可跳过。
追问
- 在哪看推导结果?答:编译器稳定性报告 / Studio 提示,具体开关路径以目标版本文档为准。
- 第三方库类型不稳定怎么办?答:在边界映射为本地不可变数据类,或按契约标注(前提是承诺成立)。
参考来源
- Android Compose 心智模型与组合机制:组合、重组与可组合项基础概念。
- Compose 状态管理:State、remember、状态读取与订阅机制。
- 状态提升与单向数据流:受控组件、参数与回调接口设计。
- Compose 副作用(Side Effects):LaunchedEffect、DisposableEffect、SideEffect 选型。
- Compose 稳定性注解:@Stable、@Immutable 与跳过判定规则。
待整理清单
- [ ] 核对目标 Compose BOM 版本下 mutableStateOf 状态策略枚举与参数名,标注「待确认」处补实测结论。
- [ ] 补充 Kotlin 2.x Compose 编译器插件对稳定性推导的具体报告入口与开关路径。
- [ ] 整理可观察集合实现与不可变集合库的选型对比。
- [ ] 补充 CompositionLocal 在导航跨页面场景下的作用域示例与调试方法。
- [ ] 收集 derivedStateOf、snapshotFlow 在真实业务列表中的性能对照案例。