【探秘 Jetpack Compose 框架深水区】第5课:组合身份与作用域边界

34 阅读35分钟

摘要:本文是 Compose 系列第 5 课,聚焦「组合身份」。从 SlotTable、组与 KeyInfo 出发,说明组身份默认由调用点与执行顺序决定,key 只是在其上叠加显式身份,并区分 remember(key) 与 key(key) { } 两套重置机制。随后拆解三条边界:key 只在同一调用点内唯一、值变化会替换整棵子树的组合身份;movableContentOf 让子树带着状态与节点在组合树内移动而身份不变,但不替代 ViewModel、是移动而非复制;CompositionLocal 的合理信号是「跨切面且中间层不应感知」,且 compositionLocalOf 与 staticCompositionLocalOf 的无效化范围完全不同。最后将三者交汇于 effect 生命周期,并配 12 道分层习题与知识点总结。适合已掌握 remember 与 effect 基础、希望理解 Compose 运行时身份模型的开发者。

目录

前言

第4课反复出现一个词,却一直没有拆开:组合身份。我们说 effect 的“离开/进入组合”判定基于组合身份而非 UI 位置;key() 改变时旧子树被丢弃,movableContentOf 移动时状态和节点跟着走、effect 不重启。但组合身份到底由什么构成、什么时候变、能不能脱离位置移动、又如何划定数据的作用域——这些问题一直悬着。

先别急着记概念,不妨换个日常的比喻。把 Compose 的组合树想象成一栋公寓楼:每个 Composable 是楼里的一个房间,房间里的家具就是 remember 存下的状态,房间里的“定时任务”就是 effect。组合身份,就是房间的门牌号。 门牌号不变,你搬进来还是原来那间房,家具还在、定时任务照跑;门牌号一变,哪怕房间长得一模一样,对物业来说也是“换了一户人家”,家具清空、任务重来。这一课要讲的三个工具,本质上都是在回答“门牌号怎么定、能不能换房间、房间里的东西归谁管”。

这一课把它们拆开。三个工具分别回答三件事:key 回答“身份如何被显式指定”,movableContentOf 回答“身份能否脱离位置移动”,CompositionLocal 回答“数据的作用域边界如何与身份边界对齐”。底层统一的前提只有一句:Compose 运行时管理的是一张由“组”构成的树,每个组有一个身份;UI 位置只是这张身份树在屏幕上的投影,不是身份本身。

读的时候可以带着三个问题往下走:门牌号是谁定的(key)?能不能带着家具换房间(movableContentOf)?房间里的水电由谁供给、供给范围到哪儿(CompositionLocal)?把这三个问题想通,后面那些“看起来反直觉”的行为,其实都是同一套规则的自然结果。


一、组合身份的底层:SlotTable、组与 KeyInfo

在理解 key 之前,需要先知道 Compose 运行时用什么数据结构保存组合状态。这一步稍微偏底层,但只需要建立一个直觉:Compose 记住的东西,是存在一张表里的,而不是存在 UI 控件上的。

SlotTable 是持久化保存组合状态的数据结构。 初始组合时被填充,重组时被读取和修改,记录的是 Composable 的状态,不是 UI 节点的状态。Composer 执行组合函数时,本质上是在 SlotTable 中定位、读取、写入“组”(group)。

每个 @Composable 调用、每个控制流分支、每个 key 调用,都会在 SlotTable 中形成一个组。 组是 SlotTable 的结构单元,有起点、终点、父子关系,以及一个身份信息——KeyInfo。KeyInfo 是组身份的底层载体,包含调用点信息(sourceInformation)和显式键(key 传入多个参数时,它们被组合成一个复合键参与 equals 与 hashCode 比较)。重组时判断“这是不是同一个组”,依据的就是这个身份:匹配则复用已有的 remember 值和节点;不匹配则丢弃旧组、创建新组。

默认情况下,组的身份由调用点信息决定;当同一调用点在组合中被多次执行时(比如一个循环),运行时按执行顺序把每次执行映射到对应的槽位。这在简单顺序流中是充分的;但一旦出现数据重排,执行顺序变化,槽位映射就会错位。

打个比方:一排没有编号的储物柜,你按“第几个来”分配柜子。今天张三第一个来,用 1 号柜;明天李四第一个来,还是用 1 号柜——柜子里的东西就串了。一个列表项从第 2 位移到第 3 位,如果身份只由调用点和顺序决定,运行时就会认为“第 2 位来了一个新东西,第 3 位也来了一个新东西”——remember 被重置,effect 被取消并重启,节点被拆除再重建。问题不在于顺序本身,而在于顺序被当成了身份。

key 的作用,就是在这个由调用点和顺序构成的隐式身份之上,叠加一个显式的、开发者提供的身份。 官方定义是:key 用于对组合中的执行块进行“分组”或“设置键”,有时这是控制流内正确性所必需的。更底层地说,key 创建一个新的 movable group,并给它一个 KeyInfo;这个身份存在 SlotTable 中,下次执行时被检查,用来判断组是被添加、删除还是重排。

下图概括了组身份从「隐式」到「显式」的构成方式:

mermaid diagram

remember(key) 与 key(key) { } 是两套不同的重置机制

初学者最容易混淆的一组概念,值得单独拆开。

remember(key1) { ... } 在 key 变化时重新计算 remember 的值,但组身份不变,同级的其他 remember 和 effect 不受影响。语义是“这个值依赖 key,key 变了就重新算这个值”。

key(key1) { ... } 在 key 变化时替换整棵子树的组合身份,子树内所有 remember 被遗忘、所有 effect 被取消、所有 onDispose 被调用。语义是“换 key,就是换一整个子树”。

@Composable
fun Profile(userId: String) {
    // 只有 scrollState 随 userId 重置,其他同级状态不受影响
    val scrollState = remember(userId) { ScrollState(0) }
    val otherState = remember { SomeState() }
    LaunchedEffect(userId) { loadProfile(userId) }
    Content(scrollState, otherState)
}
@Composable
fun Profile(userId: String) {
    // 整棵子树随 userId 重置
    key(userId) { ProfileContent() }
}

把两者混用,是“状态该重置时没重置、该保留时被清掉”的常见根源。


二、key 的边界:它改变什么,不改变什么

key 最常见的误用,是把它当成“性能优化”或“强制刷新”的工具。这两者都不准确。key 改变的是身份语义,而身份语义的后果才是性能和正确性的变化。

换句话说:key 不是油门也不是刹车,它是门牌号。你给房间换门牌号,物业就会当成新住户处理——家具清空、任务重来。这不是“变快了”或“变慢了”,而是“换人了”。理解了这一点,下面四条边界就都是它的推论。

边界一:key 只在同一调用点内部保证唯一,不是全局命名空间

官方 API 文档的表述很精确:键的值不必是全局唯一的,只需在组合过程中该 key 调用中保持唯一。同一个 user.id 可以同时出现在两个不同的循环中,只要这两个循环各自是一个独立的 key 调用点,就不会冲突。文档中的例子是两个循环:一个遍历所有 users,一个遍历 users.filter { isAdmin };同一个用户 ID 在两个循环中都出现,但由于 key 调用的位置不同,运行时可以正确区分。

但同一个集合内部,键必须唯一。如果两个元素在同一个 key 调用中传入了相等的键,子状态和本地状态可能被意外复用。文档给出的复合键方案是直接传入多个参数:key(element.id, parentId),这些参数会与之前的值用 equals 和 hashCode 比较。

边界二:key 的重新创建会重置整棵子树的组合身份,包括 remember 和 effect

当 key 的值变化时,Compose 不会“更新”旧组,而是丢弃旧组、创建新组。旧子树中的所有 remember 被遗忘,所有 LaunchedEffect 被取消,所有 DisposableEffect.onDispose 被同步调用。这不是副作用,这是 key 的契约:换 key,就是换身份;换身份,就是重来。

这解释了一个常见模式:当你希望“切换数据源时彻底重置一段 UI 的局部状态”时,用 key(dataSourceId) { Content() } 包裹是最干净的方案。它比在 Content 内部用 LaunchedEffect(dataSourceId) 去手动清理所有状态更彻底——因为 LaunchedEffect 只重启 effect,不重置 remember;而 key 重置的是整个组合身份。

边界三:key 不改变数据的流向,只改变身份

key 不会让一个值“传播”到子树,也不会让子树“跳过”重组。它只做一件事:在 SlotTable 中为一个组赋予一个显式的身份。父级传入的参数仍然通过参数传递,状态仍然通过 State 读取,effect 仍然由 key 控制。key 是身份层的操作,不是数据层的操作。

边界四:Lazy 列表的 key 是同一原理的一个特例,不是另一套机制

LazyColumn 的 items(key = { it.id }) 之所以能在插入、删除、重排时保持列表项状态,正是因为它在内部用 key 为每个 item 赋予了稳定的组合身份。如果没有提供 key,列表项的身份按位置维护;头部插入或中间删除后,后续列表项会被视作换了身份,remember / rememberSaveable 状态和组合复用都可能受影响。Lazy 列表不是“另一套身份规则”,它只是把 key 机制应用在了一个动态集合上。

一句话记住 key:它不加速任何东西,它定义“这是不是同一个东西”。


三、movableContentOf:身份可以脱离位置移动

key 解决的是“在同一位置,如何区分不同的身份”。movableContentOf 解决的是一个更反直觉的问题:能不能让一个子树在组合树中换一个位置,而身份保持不变?

它到底做了什么

官方定义:movableContentOf 将 lambda 转换为一个 lambda,该 lambda 将它记住的状态和在上次调用中创建的节点移动到它被调用的新位置。它“移动”的不是 UI 的视觉位置,而是 SlotTable 中整个子树的组合状态和已创建的布局节点。设计文档的表述更直接:它允许以抽象方式保留一个 composition 的内部状态,使整棵树可以在层级结构中移动。

底层实现上,movableContentOf 返回一个 MovableContent 对象;这个对象在内部持有 lambda 以及一个 MovableContentStateReference——后者记录的是上一次调用时在 SlotTable 中创建的组和节点。当它在新位置被调用时,运行时的 Composer 会把旧位置的组和节点“搬运”到新位置,而不是丢弃重建。

一个最小示例,来自官方文档:

val movableContent = remember(content) {
    movableContentOf(content)
}
if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

当 vertical 切换时,content 子树从 Column 移到 Row。如果没有 movableContentOf,这会表现为“旧子树离开组合、新子树进入组合”——remember 丢失,effect 重启。有了它,子树带着状态和节点一起移动,组合身份不变。

下图对比了「无 movableContentOf」与「有 movableContentOf」两种情况下子树换位置的行为差异:

mermaid diagram

这里需要点出一个容易忽略的细节:remember(content) { movableContentOf(content) } 中的 content 作为 key,意味着当 content lambda 本身变化时,会重新创建一个 MovableContent 对象。如果 content 是不稳定的 lambda(每次重组都创建新实例),movableContentOf 的身份就会随之重建,移动语义失效。正确的做法是让 content 保持稳定,或使用 rememberUpdatedState 让 lambda 读最新值但不重建身份。

更贴近实际场景的例子是跨容器分组布局:一个 items 列表需要根据宽度分成多列,每个 item 的状态必须随着 item 在列之间移动而保持。官方文档的示例用 itemMap 缓存每个 item 的 movableContentOf,在 Row 中按列分配 item 时,同一个 item 的 content 无论落在哪一列,都保持自己的状态。

边界一:它移动的是“当前调用中创建的状态和节点”,不是任意历史快照

movableContentOf 持有的是上一次调用时创建的那个子树。当它在新的位置被调用时,运行时把那个子树搬过去。它不负责“恢复”一个已经被彻底丢弃的历史状态,也不负责跨 composition 实例搬运。如果 movableContentOf lambda 在同一个组合中被多次调用,每次调用都会创建新的状态和节点。这意味着它不是一个“全局状态容器”,它的语义严格限定在“一次移动,带着当前状态走”。

边界二:它不替代 ViewModel 的状态提升

movableContentOf 让 UI 状态跟随组合身份移动,但它不能让业务状态在组合销毁后存活。如果一段内容离开组合后没有被重新插入,它持有的状态最终会被永久移除,并通知 remember 观察者。它解决的是“同一 composition 内的位置迁移”,不是“跨生命周期的状态持久化”。后者仍然是 ViewModel 或 rememberSaveable 的职责。

边界三:它的代价是“移动”不是“复制”

因为节点和状态是一起移动的,所以源位置的组合槽位会被释放,目标位置被填充。如果你在两个位置同时调用同一个 movableContentOf lambda,它们不会共享状态,而是各自拥有独立的状态和节点。移动语义和复制语义在这里是互斥的。

一句话记住 movableContentOf:它让身份跟着内容走,而不是让内容跟着位置走。


四、CompositionLocal:数据的作用域边界与无效化边界

key 和 movableContentOf 处理的是“子树在组合树中的身份”。CompositionLocal 处理的是另一条边界:一个值如何沿着组合身份树向下传递,以及它的变化如何决定哪一部分树被无效化。

它解决的真实问题:不是“传递方便”,而是“中间层不该知道”

CompositionLocal 常被描述为“隐式传参”,但它的设计意图比这个描述更窄。官方文档明确指出,使用它的一个重要信号是:参数是跨切面的,而实现中的中间层不应该知道这个参数的存在;如果让中间层知道,会限制 composable 的可用性。主题色、排版、布局方向是典型例子:它们需要被深层组件读取,但中间每一层组件都不应该被迫声明一个 colors: Colors 参数。

官方同时给出了一条明确的负面信号:避免创建一个只作用于某个特定屏幕的 CompositionLocal。如果这个值只在某一个页面的子树中使用,参数传递是更诚实的边界;CompositionLocal 的合理性来自“跨切面”,而不是“少写一个参数”。

还有一个基础但容易忽略的机制:CompositionLocal.current 在没有最近的 provider 时,会回退到创建时提供的默认值;如果创建时没有提供默认值(compositionLocalOf<T>() 或 staticCompositionLocalOf<T>() 不带参数),读取会抛出异常。这意味着 CompositionLocal 的默认值不是“可选的便利”,它是这个 local 在整棵组合树中的兜底语义。

边界一:compositionLocalOf 与 staticCompositionLocalOf 的无效化范围完全不同

这是 CompositionLocal 深水区里最容易出错的一条边界。官方文档的表述几乎没有歧义:staticCompositionLocalOf 的读取不被 composer 追踪,改变 CompositionLocalProvider 中提供的值会导致整个 content 被重组,而不仅仅是读取该值的位置被重组。compositionLocalOf 则追踪读取,值变化只使实际读取 current 的消费者失效。

底层机制上,compositionLocalOf 返回的 DynamicProvidableCompositionLocal 在 current 读取时会调用 composer.consume(this),把当前 local 记录为该组合位置的读取依赖;staticCompositionLocalOf 返回的 StaticProvidableCompositionLocal 不做这一步,因此 composer 不知道哪些位置读了它,只能在 provider 值变化时把整个 content 标记为无效。

这意味着:

  • 用 compositionLocalOf 提供一个会变化的值,子树中只有读取它的位置被无效化。粒度是“谁读谁重组”。
  • 用 staticCompositionLocalOf 提供一个会变化的值,整个 provider 的 content 范围都会被重组。粒度是“提供范围整体”。
  • 官方对 staticCompositionLocalOf 的推荐条件是:值极不可能变化或永远不会变化;因为缺少读取追踪,当值确实稳定时,它反而更高效。

一个具体的误用模式是:为了让某个“可能变化”的值传递方便,随手用了 staticCompositionLocalOf。结果每次值变化,整个子树——包括那些根本不关心这个值的部分——都被重组。这不是性能优化,这是性能惩罚。

下图对比两种 local 在值变化时的无效化范围:

mermaid diagram

边界二:CompositionLocal 的提供范围就是它的作用域边界,而作用域由组合身份定义

CompositionLocalProvider 把值绑定到一个 ProvidableCompositionLocal 键,在 content lambda 中直接或间接调用的 composable 读取 current 时,返回最近祖先提供的值。作用域限定为组合的一部分,因此可以在树的不同层级提供不同的值;current 返回的是祖先在该组合部分中提供的最近值。

这里的关键不是“最近的 provider 赢了”,而是:provider 的边界和组合身份的边界是同一套边界。 如果一个子树因为 key 变化而被丢弃重建,它内部的 CompositionLocal 读取关系也随之重建;如果一个子树通过 movableContentOf 被移动到新的 provider 之下,它读取的 current 会解析为新位置最近的祖先提供的值。数据作用域不会脱离身份作用域独立存在。

边界三:它不应该替代显式参数,只应该处理“跨切面且中间层不应感知”的值

官方文档对过度使用的警告很直接:CompositionLocal 让 composable 的行为更难理解,因为它引入了隐式依赖;一个 composable 读取了哪个 local,从签名上看不出来。参数传递让依赖显式,CompositionLocal 让依赖隐式。只有当“隐式”本身就是设计目标时——比如主题系统,或者布局方向——这种隐式才是合理的。用一个 CompositionLocal 来传递一个页面级的业务对象,通常是在用隐式机制解决一个本该用显式参数解决的问题。

一句话记住 CompositionLocal:它的边界不是“能不能传”,而是“该不该让中间层看不见”;它的无效化范围由 static 与动态的选择直接决定。


五、三条边界的交汇:身份、移动、作用域如何共同决定 effect 的生命周期

回到第4课的问题。effect 是否重启,由三条正交路径共同决定:

路径一:key 改变,身份被替换,effect 必然重启。 旧组的 LaunchedEffect 协程被取消,onDispose 被同步调用,新组重新启动 effect。

路径二:movableContentOf 移动,位置变、身份不变,effect 不重启。 节点和状态被搬运,LaunchedEffect 协程继续存活,remember 不丢失。

路径三:CompositionLocal 的值变化,effect 是否重启取决于两个独立问题。 第一个问题是“包含 effect 的组合位置是否被重新执行”,由 local 的无效化范围决定;第二个问题是“effect 的 key 是否变化”,由 key 表达式中是否读取了该 local 的值决定。两个答案组合起来,才是最终行为:

无效化范围key 中是否读取 local组合位置重新执行effect 重启
static是是(整个 content)是(key 变了)
static否是(整个 content)否(key 没变)
dynamic是是(仅读者)是(key 变了)
dynamic否否(effect 位置不读 local)否

这张表说明:“组合位置被重新执行”和“effect 重启”是两个不同的问题。 前者由无效化范围决定,后者由 key 语义决定。很多人把它们混为一谈,导致对 static local 在 effect 场景下的行为预测出错。

下图把三条路径收敛为一张 effect 生命周期判定流程:

mermaid diagram

这三条路径共同说明:effect 的生命周期锚点不是一个抽象概念,它在 SlotTable 中有具体的载体。 key 操作这个载体的 KeyInfo,movableContentOf 操作这个载体的物理位置,CompositionLocal 操作这个载体读取数据时的作用域解析。理解载体,才能预测 effect 什么时候走、什么时候留。


六、习题:12 道身份与作用域边界检验

第 1 题(选择)

下列关于 key 的说法,正确的是: A. key 的值必须在整个应用中全局唯一 B. key 的值只需在同一个 key 调用点内唯一 C. key 的值变化时,子树中的 remember 保留,只有 effect 重启 D. key 是一种性能优化,不会改变组合身份

参考答案:B。

解读: key 的值不必全局唯一,只需在同一个 key 调用点内唯一。官方文档明确说,同一个 user.id 可以同时出现在两个不同的循环中,因为 key 调用位置不同,运行时可以区分。C 错在把 key 的后果说小了:key 变化替换的是整棵子树的组合身份,remember 会被遗忘、effect 会被取消、onDispose 会被同步调用,远不止“effect 重启”。D 错在把 key 当成了优化开关:它操作的是身份语义,身份变化带来的性能和正确性后果是结果,不是目的。

第 2 题(判断)

两个不同的循环中使用了相同的 key(user.id),一定会导致状态串用。

参考答案:错。

解读: 不同循环是不同的 key 调用点。官方文档恰好用“顶部循环 + 底部循环”这个例子说明:同一个 user.id 在两个循环中都出现,由于 key 调用位置不同,不需要创建复合键。真正需要唯一的是同一个 key 调用内部的键。如果同一个集合中两个元素传入了相等的键,子状态才可能被意外复用,此时才需要用 key(element.id, parentId) 这样的复合键来区分。

第 3 题(代码分析)

下面代码在 userId 变化时,remember 中的 scrollState 会怎样?如果想在 userId 变化时重置滚动位置,最干净的写法是什么?

@Composable
fun Profile(userId: String) {
    val scrollState = remember { ScrollState(0) }
    LaunchedEffect(userId) { loadProfile(userId) }
    Content(scrollState)
}

参考答案: scrollState 不会被重置。userId 变化只让 LaunchedEffect 的 key 变化,从而取消并重启 effect;remember { ScrollState(0) } 没有以 userId 为 key,它的组合身份没有变,会保留上一个用户的值。最干净的写法是用 key(userId) { ProfileContent() } 包裹整棵子树,让组合身份随 userId 替换,remember 和 effect 一起重置。

解读: 这道题直接对应第4课里 produceState 的 initialValue 不重置问题,根源完全相同:remember 的生命周期由组合身份决定,不由参数决定。很多人以为“effect 的 key 变了,相关状态就会重置”,这是把 effect 的时间边界和 remember 的存储边界混为一谈。LaunchedEffect(userId) 只负责“当 userId 变化时重新执行这个 effect”,它不负责清理同级的 remember。要同时重置两者,key 是唯一正确的工具;在 effect 内部手动给 scrollState 赋值是补丁,会漏掉其他 remember,也会在首次组合时产生多余写入。另一个容易混淆的替代方案是 remember(userId) { ScrollState(0) }——它确实会在 userId 变化时重置 scrollState,但同级的其他 remember 仍然保留,语义上是“只重置这一个值”,不是“重置整段 UI”。选择哪个工具,取决于你要重置的是一个值还是整段界面。

第 4 题(简答)

从 SlotTable 的角度解释:为什么 key 变化会导致整棵子树的 remember 被重置,而不是只更新某些槽位?

参考答案: SlotTable 中每个组有一个身份,remember 的值存在组的槽位里。重组时,如果 key 值变化,运行时在 SlotTable 中找不到匹配的 KeyInfo,于是丢弃旧组、创建新组。组被丢弃,槽位随之失效,所以不是“更新某些槽位”,而是“整棵子树的组生命周期结束、新的组生命周期开始”。DisposableEffect.onDispose 的同步调用、LaunchedEffect 的取消,都是这个“组生命周期结束”的后果。

解读: 这道题考的是把“key 变化重置状态”从一个经验结论提升到数据结构层面的因果解释。关键区分是“更新”与“替换”:如果运行时选择“更新槽位”,那 remember 的初始值逻辑、effect 的 key 比较、onDispose 的配对语义都会变得不可定义;选择“替换组”,这些语义才有清晰的边界。理解这一点,就能理解为什么 key 是“重置子树”最彻底也最可预测的工具。

第 5 题(选择)

movableContentOf 的核心语义是: A. 把 content 复制到新位置,原位置保留 B. 把 content 记住的状态和已创建节点移动到新位置 C. 强制 content 在新位置重建,但保留状态 D. 让 content 脱离组合树独立存在

参考答案:B。

解读: 官方定义就是“移动它记住的状态和在上次调用中创建的节点”。A 错在“复制”:它是移动,源位置的槽位被释放;同一个 movable lambda 在同一个组合中多次调用,会各自创建新状态和节点,而不是共享。C 错在“重建”:重建意味着旧节点被拆除、新节点被创建,而 movableContentOf 恰恰是要避免这种拆除重建。D 错得最远:它仍然是组合树的一部分,只是可以在树内移动,不能脱离组合树独立存在。

第 6 题(场景设计)

一个响应式布局需要在宽度变化时把一个 item 从一列移到另一列,同时保持该 item 的 remember 状态和正在运行的 LaunchedEffect 不中断。应该使用什么工具?它的边界是什么?

参考答案: 使用 movableContentOf。为每个 item 用 remember { movableContentOf { ItemContent(item) } } 缓存一个 movable lambda,在列之间移动时调用同一个 lambda,子树会带着 remember 状态和已创建节点移动,LaunchedEffect 不重启。边界有三条:它只能在同一个 composition 内移动;如果 item 永久离开组合且没有被重新插入,状态最终会被移除;它不能替代跨组合实例的状态持久化。另外,每个 item 需要自己的 movableContentOf 实例,不能用一个共享 lambda 同时渲染多个 item。

解读: 这道题对应官方文档里“按宽度分列”的经典用例。关键是要说清“为什么不用别的”:用 key 做不到,因为 key 变化会重置状态;用状态提升可以做到,但会把 item 的局部状态全部上提到父级,违背封装;用 movableContentOf 是唯一能同时满足“位置变、身份不变、节点不重建”的工具。边界部分考的是不要把它神化:它不是 ViewModel,不是全局状态容器,也不是复制语义。还有一个实践细节:如果 ItemContent(item) 里的 item 是每次重组新建的对象,remember { movableContentOf { ItemContent(item) } } 里的 lambda 捕获的是旧 item;如果希望 item 数据更新但身份不重置,需要在 movable lambda 内部用 rememberUpdatedState 读最新的 item,或者让 item 保持稳定。

第 7 题(判断)

movableContentOf 可以让状态在组合被销毁后仍然存活,因此可以替代 ViewModel。

参考答案:错。

解读: movableContentOf 移动的是当前 composition 中的状态和节点。如果内容离开组合且没有被重新插入,状态会被永久移除,并通知 remember 观察者。它不提供跨组合实例或跨进程的生命周期持久化。跨配置变更、进程重建的状态存活,仍然是 ViewModel 或 rememberSaveable 的职责。把两者混为一谈,会导致“旋转屏幕后状态丢失”这类问题被误判为 movableContentOf 的 bug。

第 8 题(选择)

关于 compositionLocalOf 和 staticCompositionLocalOf 的无效化范围,正确的是: A. 两者值变化时都只让读取该值的位置重组 B. 两者值变化时都让整个 provider content 重组 C. compositionLocalOf 追踪读取,只失效读取位置;staticCompositionLocalOf 不追踪,值变化会重组整个 content D. staticCompositionLocalOf 追踪读取,compositionLocalOf 不追踪

参考答案:C。

解读: 官方表述几乎没有歧义:staticCompositionLocalOf 的读取不被 composer 追踪,值变化导致整个 content 被重组;compositionLocalOf 追踪读取,只失效实际读取位置。底层机制是 DynamicProvidableCompositionLocal.current 会调用 composer.consume(this) 注册读取依赖,而 StaticProvidableCompositionLocal 不做这一步。D 把两者的追踪行为说反了。A 和 B 都把它们当成同一种行为,忽略了这条核心分界。这条分界的实践意义是:static 不是“更快的 compositionLocalOf”,它是“用无效化范围换读取开销”的另一种权衡,只适合真正稳定的值。

第 9 题(简答)

官方文档说 CompositionLocal 的一个重要使用信号是“中间层不应该知道这个参数的存在”。请解释为什么“少写一个参数”本身不是使用它的充分理由。

参考答案: 因为“少写参数”是一个可以用参数默认值、扩展函数或组合封装解决的表面问题,而 CompositionLocal 引入的是隐式依赖:一个 composable 读取了哪个 local,从它的签名上看不出来,行为更难推理。官方推荐的使用信号是“参数跨切面,且中间层不应知道其存在”——主题、布局方向、密度是典型例子。如果中间层本来就有权知道这个依赖,或者这个依赖只作用于一个特定屏幕,显式参数是更诚实的边界。官方甚至明确说,只作用于某个特定屏幕的 CompositionLocal 是坏实践。

解读: 这道题考的是把 CompositionLocal 从“方便的传参工具”还原为“有代价的隐式依赖机制”。判断标准不是“参数穿了几层”,而是“中间层知道这个依赖会不会损害它的可复用性”。主题色穿过十几层组件,中间层不应该关心颜色,所以隐式是合理的;一个页面的 userId 穿过三层,中间层本来就在这个页面的语境里,隐式反而让依赖变得模糊。这条边界不守住,CompositionLocal 会变成全局变量的温和版本。

第 10 题(代码分析)

下面代码用 staticCompositionLocalOf 传递一个会变化的 userId。它有什么问题?如果改成 compositionLocalOf,无效化范围会怎样变化?

val LocalUserId = staticCompositionLocalOf { "" }

@Composable
fun App(userId: String) {
    CompositionLocalProvider(LocalUserId provides userId) {
        HeavySubtree()   // 内部只有深层某个组件读取 LocalUserId
    }
}

参考答案: 问题在于 userId 是会变化的值,而 staticCompositionLocalOf 不追踪读取,每次 userId 变化都会重组 CompositionLocalProvider 的整个 content 范围,包括 HeavySubtree 中所有不读取 LocalUserId 的部分。改成 compositionLocalOf 后,只有实际读取 LocalUserId.current 的位置被失效,HeavySubtree 中不读取该 local 的部分不会被重组。代价是动态 local 有读取追踪的开销;如果值确实稳定,static 反而更高效。

解读: 这是 CompositionLocal 深水区最典型的性能陷阱:用 static 传递一个会变的值,看起来语法更简单,实际上把无效化范围从“读者”放大到“整个提供范围”。这道题的关键不是记住“动态值用 compositionLocalOf”这个口诀,而是理解两种 local 的追踪机制不同:static 用“不追踪”换“读取零开销”,dynamic 用“读取追踪开销”换“精确失效”。选择依据是值的稳定性,不是个人偏好。

第 11 题(判断)

CompositionLocal 的提供范围边界和组合身份边界是两套独立的机制,互不影响。

参考答案:错。

解读: 官方文档说 CompositionLocalProvider 的作用域“限定为组合的一部分”,这句话本身就说明它的边界是组合树上的一个节点及其子树,而组合树的结构正是由组合身份定义的。当子树因为 key 变化被丢弃重建时,CompositionLocal 的读取关系也随之重建;当子树通过 movableContentOf 移动到新的 provider 之下时,它读取的 current 会解析为新位置最近的祖先提供的值。数据作用域不会脱离身份作用域独立存在。把两者当成独立机制,会低估 key 和 movableContentOf 对 CompositionLocal 解析结果的影响。

第 12 题(综合简答)

一个 LaunchedEffect 的 key 中包含 LocalConfig.current.someFlag,而 LocalConfig 是用 staticCompositionLocalOf 提供的。当 someFlag 变化时,effect 会怎样?请从“CompositionLocal 的无效化范围”和“LaunchedEffect 的 key 语义”两个层面解释。

参考答案: 两层同时起作用。CompositionLocal 层:staticCompositionLocalOf 的值变化会重组整个 provider content 范围,因此包含该 LaunchedEffect 的组合位置会被重新执行,effect 的 key 表达式被重新求值。LaunchedEffect 层:如果 someFlag 的变化导致 key 中的值真的变了,effect 的 key 不相等,旧协程被取消、新协程启动。需要注意一个容易被忽略的点:即使 key 没有变化,static 的无效化也会让包含 effect 的组合位置重新执行一次(effect 本身不重启,但组合函数体被再次调用)。如果换成 compositionLocalOf,只有读取 LocalConfig.current 的位置被失效;effect 是否重启,仍然只取决于 key 是否变化。

解读: 这道题的价值在于把两个正交机制叠加到同一段代码上分析。CompositionLocal 的无效化范围回答“哪些组合位置会被重新执行”,LaunchedEffect 的 key 语义回答“effect 协程会不会重启”。两者不是同一个问题:组合位置被重新执行,不代表 effect 一定重启;effect 重启,一定意味着它所在的组合位置至少被重新执行过一次。把这两个层面分开,才能准确预测 static 与 dynamic 在 effect 场景下的行为差异——这也是第4课“时间边界”和本课“作用域边界”真正交汇的地方。


七、本节课知识点总结

组合身份的底层载体。 SlotTable 持久化保存组合状态;每个 @Composable 调用、控制流分支、key 调用都形成一个组;组身份由 KeyInfo 承载,默认由调用点和执行顺序决定,key 叠加显式身份。身份匹配则复用槽位,身份不匹配则丢弃旧组、创建新组。remember(key) 与 key(key) { } 是两套不同的重置机制:前者重置一个值,后者重置整棵子树的身份。

key 的边界。 只在同一调用点内保证唯一,不是全局命名空间;值变化替换整棵子树的组合身份,remember 重置、effect 取消、onDispose 同步调用;不改变数据流向,只定义“是不是同一个东西”;Lazy 列表的 key 是同一机制在动态集合上的应用。

movableContentOf 的边界。 移动的是“上次调用中创建的状态和节点”,不是复制,不是跨组合实例搬运;同一 movable lambda 多次调用会各自创建新状态;它持有 MovableContentStateReference,在 SlotTable 中搬运组和节点;不替代 ViewModel;它让身份跟着内容走,而不是让内容跟着位置走。

CompositionLocal 的边界。 compositionLocalOf 追踪读取(composer.consume),只失效实际消费者;staticCompositionLocalOf 不追踪,值变化重组整个 content 范围,只适合真正稳定的值。它的合理使用信号是“跨切面且中间层不应知道”,不是“少写参数”;特定屏幕专用的 local 是坏实践。current 在没有 provider 时回退到默认值,无默认值则抛异常。提供范围边界与组合身份边界是同一套边界,不是两套独立机制。

三条边界的交汇。 effect 是否重启由三条正交路径共同决定:key 改身份,effect 必重启;movableContentOf 改位置不改身份,effect 不重启;CompositionLocal 的值变化时,“组合位置是否重新执行”由无效化范围决定,“effect 是否重启”由 key 语义决定,两者是不同的问题。effect 的生命周期锚点在 SlotTable 中有具体载体:KeyInfo、物理位置、作用域解析。

一句话收束: 第3课的 remember 回答“值存在哪儿”,第4课的 effect 回答“动作拴在哪儿”,这一课回答的是:“哪儿”本身由什么定义。 答案是组合身份——一个由 SlotTable 中的组承载、可以被显式指定、可以脱离位置移动、并且划定了数据作用域边界的东西。看懂身份,才能看懂 Compose 真正在管理什么。


八、下期预告

第6课:derivedStateOf 的边界在哪里?

第3课讲了 remember 的存储边界,第5课讲了组合身份如何定义“值存在哪个生命周期里”。但有一个问题,前三课和第4课都只是擦边:如果一个状态是由另一个状态“算出来”的,什么时候该用 derivedStateOf,什么时候用 remember(key) { ... } 或 snapshotFlow 就够了?

derivedStateOf 经常被当成“性能优化”的万能标签,但它的真正边界在于快照读取的依赖追踪:它追踪的是“计算过程中读取了哪些 State”,而不是“你传入了哪些参数”。这意味着它可以减少重组,但也意味着它的依赖集是动态的、由运行时决定的。如果计算中读取了不该读的值,或者把 derivedStateOf 用在一个本不该产生状态的地方,它会静默地引入难以排查的无效化行为。

下一课拆三件事:derivedStateOf 的依赖追踪到底追踪什么;它和 remember(key)、snapshotFlow 的边界分别在哪里;以及“派生状态”这个模式在快照系统中到底应该被放在哪一层。第5课讲的是身份——值活在哪个组合位置上;第6课讲的是值如何从别的值中派生出来,而派生过程的边界又由什么定义。