罗罗编程学习记录
本页内容 展开查看

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 提示,具体开关路径以目标版本文档为准。
  • 第三方库类型不稳定怎么办?答:在边界映射为本地不可变数据类,或按契约标注(前提是承诺成立)。

参考来源

待整理清单

  • [ ] 核对目标 Compose BOM 版本下 mutableStateOf 状态策略枚举与参数名,标注「待确认」处补实测结论。
  • [ ] 补充 Kotlin 2.x Compose 编译器插件对稳定性推导的具体报告入口与开关路径。
  • [ ] 整理可观察集合实现与不可变集合库的选型对比。
  • [ ] 补充 CompositionLocal 在导航跨页面场景下的作用域示例与调试方法。
  • [ ] 收集 derivedStateOf、snapshotFlow 在真实业务列表中的性能对照案例。