Android Compose 可组合项的生命周期

原创 已于 2025-10-16 14:05:58 修改 · 1.1k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #Compose #可组合项 #生命周期 #Composition #重组 #recompose

于 2025-10-16 09:03:08 首次发布

王者杯·14天创作挑战营·第6期 10w+人浏览 658人参与

Jetpack Compose 可组合项的生命周期

如果你刚接触 Compose，可能会对“可组合项生命周期”、“重组”这些词感到困惑。其实它们的核心逻辑很简单——本质是 Compose 如何“聪明地更新界面”，避免做无用功。

一、生命周期概览：可组合项的“一生”

首先要明确三个基础概念：

组合（Composition）：是 Compose 根据你编写的可组合项代码，最终构建出的 “界面完整描述”。它代表了 “当前界面应该由哪些元素组成、这些元素如何关联、依赖哪些状态” 的整体逻辑。

组合树（Composition Tree） : 是实现组合的具体数据结构，它代表了 UI 的层次结构。这是一个内存中的树形数据结构，描述了应用中所有可组合项的布局和关系。

@Composable
fun MyScreen() {
    Column {          // ← 树的根节点
        Text("Hello") // ← 子节点
        Button(       // ← 子节点
            onClick = { /* ... */ }
        ) {
            Text("Click me") // ← 孙子节点
        }
    }
}

对应的组合树结构：

Column
├── Text("Hello")
└── Button
    └── Text("Click me")

重组（Recomposition）：当界面状态变了（比如按钮被点击、数据加载完成），Compose 不会重新画整个组合树，而是只重新画“需要变的部分”，这个局部修改的过程就是重组。

可组合项的“一生”只有 3 步，非常简单：

  1. 进入组合：第一次被加入组合树（比如界面刚打开时，Text 被显示出来）；
  2. 0 次或多次重组：如果状态变化影响到它，就会被重组（比如 Text 显示的文字从“Hello”改成“Hi”）；如果状态没影响它，就不重组；
  3. 退出组合：从组合树中消失（比如界面关闭、列表项被删除）。

在这里插入图片描述

几个关键提醒：

  • 可组合项的生命周期比 Activity、Fragment 简单多了！如果需要处理复杂的外部资源（比如联网、注册监听），别自己硬扛，用 Compose 提供的“效应（Effect）”工具（文档后面会讲，这里先知道就行）。
  • 同一个可组合项调用多次，就会生成多个“分身”，每个“分身”有自己的生命周期。比如：
    @Composable
fun MyScreen() {
  Column {
    Text("你好") // 分身 1：有自己的生命周期
    Text("世界") // 分身 2：另一个独立的生命周期
  }
}
    这两个 Text 虽然代码一样，但在组合树里是两个不同的位置，所以是独立的。

在这里插入图片描述

二、组合中可组合项的“身份标识”：调用点

Compose 怎么区分不同的可组合项“分身”？关键看 调用点——也就是你在代码里“调用这个可组合项的位置”。

比如登录界面的例子：

@Composable
fun LoginScreen(showError: Boolean) {
  if (showError) {
    LoginError() // 调用点 1：只有 showError 为 true 时才执行
  }
  LoginInput() // 调用点 2：每次都执行
}
  • LoginError 的调用点在 if 里面，只有 showError=true 时才会进入组合树；
  • LoginInput 的调用点在 if 外面，每次都会在组合树里，而且不管 showError 怎么变，它的调用点没变，所以只要它的参数没改，重组时就会被“跳过”（不重新执行）。

核心逻辑：

重组时，Compose 会对比“这次的设计图”和“上次的设计图”：

  1. 先看“调用点”——如果某个可组合项的调用点没变（比如 LoginInput 一直在 if 外面）；
  2. 再看“输入参数”——如果参数也没变（比如 LoginInput 没有依赖 showError）；
  3. 满足以上两点，就直接复用上次的结果，不重新执行（跳过重组）。

三、解决列表“乱重组”：给可组合项加个“身份证”（key）

列表是最容易出问题的场景。比如电影列表，没加 key 时会怎样？

问题场景：

@Composable
fun MoviesScreen(movies: List<Movie>) {
  Column {
    for (movie in movies) {
      MovieOverview(movie) // 靠“循环顺序”识别：第 1 个、第 2 个...
    }
  }
}

如果在列表顶部加一部新电影：

  • Compose 原本靠“顺序”识别——原来的第 1 部电影，现在变成了第 2 部；
  • Compose 会以为“原来的第 1 部没了，新来了一个第 1 部”，于是让所有电影的 MovieOverview 都重组；
  • 如果 MovieOverview 里有“加载图片”这类操作（叫“附带效应”），就会被中断、重新加载，既浪费资源又影响体验。

解决办法：用 key 给每个可组合项加“身份证”

key 就像身份证号，让 Compose 靠“唯一标识”识别，而不是靠“顺序”。比如用电影的 id 当 key：

@Composable
fun MoviesScreenWithKey(movies: List<Movie>) {
  Column {
    for (movie in movies) {
      key(movie.id) { // 用电影的唯一 id 当“身份证”
        MovieOverview(movie)
      }
    }
  }
}

现在再在顶部加新电影：

  • Compose 会看 key（电影 id）——原来的电影 id 都还在，只是多了一个新 id；
  • 所以只会新创建“新电影”的 MovieOverview，原来的电影完全复用，加载图片的操作也不会中断。

小技巧：

像 LazyColumn（列表懒加载）这类常用组件，已经内置了 key 的支持，不用自己写循环：

@Composable
fun MoviesScreenLazy(movies: List<Movie>) {
  LazyColumn {
    // 直接在 items 里指定 key 为 movie.id
    items(movies, key = { movie -> movie.id }) { movie ->
      MovieOverview(movie)
    }
  }
}

四、什么时候能“跳过重组”：稳定类型 + 输入未变

前面提到“输入参数没变就跳过重组”，但这里有个前提：参数的类型必须是“稳定类型”。

1. 什么是“稳定类型”？

简单说，稳定类型要满足两个条件：

  • 「不变则不变」：如果两个实例的内容一样，用 equals 比较一定返回 true（比如 1 和 1 肯定相等，“苹果”和“苹果”肯定相等）；
  • 「变了会通知」：如果实例的内容变了，Compose 能知道（比如 MutableState，值变了会自动通知界面）。

2. 哪些类型天生是稳定的？

不用额外操作，Compose 自动认：

  • 基本类型：Int、Boolean、Long、Float 等（比如 1 不会突然变成 2，变了也能直接看出来）；
  • String：比如“Hello”不会自己变成“Hi”；
  • 函数/lambda：比如你传的点击事件 onClick = { ... }，只要没重新定义，就是同一个；
  • MutableState：Compose 专门设计的状态类，值变了会主动通知重组（比如 var name by remember { mutableStateOf("") }）。

3. 类型不稳定怎么办？用 @Stable 注解

比如接口类型，Compose 默认觉得它“不稳定”（因为不知道实现类会不会偷偷改值）。这时候可以给接口加 @Stable 注解，告诉 Compose：“放心，这个类型是稳定的，变了会通知你”。

例子：

// 给接口加 @Stable，告诉 Compose 它是稳定的
@Stable
interface UiState<T : Result<T>> {
  val value: T?          // 数据值
  val exception: Throwable? // 错误信息
  val hasError: Boolean get() = exception != null // 计算属性，靠 exception 决定
}

加了 @Stable 后，只要 UiState 的 value 和 exception 没变，用它当参数的可组合项就会跳过重组。

4. 最终结论：

只有满足以下两个条件，Compose 才会跳过重组：

  1. 可组合项的所有输入参数都是稳定类型；
  2. 这些参数的值和上次相比没有变化（用 equals 判断）。

五、如果不是稳定类型，为什么输入未变，也不会跳过重组 ?

本质是因为 Compose 无法 “信任” 不稳定类型的 “值未变” : 它无法可靠判断这类类型的内部状态是否真的没变化，所以会被迫触发重组以避免漏更。

要理解这个结论，需要先明确两个关键前提

1. 稳定类型 vs 不稳定类型的核心区别

Compose 对 “是否跳过重组” 的判断，本质是看它能否确定参数的值是否真的未变化

  • 稳定类型：Compose 能 100% 确认值的变化（比如 Int、String 这类不可变类型，或 MutableState 这类 “变了会主动通知” 的类型）。只要值没改，就敢跳过重组；
  • 不稳定类型：Compose 无法确认值的变化（比如 List 接口、含 var 属性的类、未注解的自定义类）—— 即使表面上 “值没变”，Compose 也担心其内部状态可能偷偷修改（且没通知自己），所以不敢跳过重组。

2. 不稳定类型为何 “输入未变也不跳过”

当可组合项包含 “不稳定参数” 时，Compose 每次重组它的父组件时，都会强制重组这个可组合项 —— 无论参数的实际值是否变化。
原因很简单：
不稳定类型的 “值是否变化” 对 Compose 是 “黑箱”。比如：

  • 你传一个 List 作为参数（List 是接口，默认不稳定）：即使列表内容没改，Compose 也无法确定你有没有在别处偷偷调用 list.add()（虽然你没这么做，但 Compose 无法预判）；
  • 你传一个含 var 属性的类 data class User(var name: String)（默认不稳定）：即使当前 name 没改，Compose 也担心你可能在其他地方修改 user.name（且没通知它）。

为了避免 “值变了但没重组导致 UI 不一致” 的 bug，Compose 对不稳定参数采取 “宁错杀、不遗漏” 的策略 —— 只要父组件重组，就强制重组这个可组合项，哪怕输入实际没变化。

3. 举个例子：不稳定类型导致 “无效重组”

比如一个显示用户列表的组件，用普通 List（不稳定类型）作为参数：

// 1. 不稳定的参数类型：List 是接口，默认不稳定
@Composable
fun UserList(users: List<User>) { 
  LazyColumn {
    items(users) { user ->
      UserItem(user) // 只要父组件重组，即使 users 内容没改，UserItem 也会重组
    }
  }
}

// 2. 父组件：有一个无关的状态变化（比如按钮点击计数）
@Composable
fun ParentScreen() {
  var clickCount by remember { mutableStateOf(0) } // 无关状态
  val users = remember { listOf(User("张三"), User("李四")) } // 内容不变的列表

  Column {
    Button(onClick = { clickCount++ }) { // 点击按钮会触发父组件重组
      Text("点击计数：$clickCount")
    }
    UserList(users) // users 是 List（不稳定），即使内容没改，也会跟着重组
  }
}
  • 当你点击 “计数按钮” 时，clickCount 变化会触发 ParentScreen 重组；
  • 虽然 users 的内容完全没变化，但因为 users 是 List（不稳定类型），UserList 和里面的 UserItem 都会被强制重组 —— 这就是 “无效重组”，会浪费性能。

4. 如何解决：把不稳定类型改成稳定类型

如果想让 “输入未变时跳过重组”，只需将参数类型改为稳定类型，比如：

  • 用不可变集合替代普通集合：用 kotlinx.collections.immutable.ImmutableList（稳定类型）替代 List；
  • 给自定义类加稳定性注解：用 @Immutable 标记不可变类，或用 @Stable 标记 “可变但会通知变化” 的类；
  • 用 Compose 自带的稳定状态类：比如 MutableState<List>（稳定类型，因为变化会通知）。

修改后的例子（稳定类型）

// 1. 稳定的参数类型：ImmutableList（不可变集合，稳定）
@Composable
fun UserList(users: ImmutableList<User>) { 
  LazyColumn {
    items(users) { user ->
      UserItem(user) // 只要 users 内容没改，就会跳过重组
    }
  }
}

// 2. 父组件：使用 ImmutableList
@Composable
fun ParentScreen() {
  var clickCount by remember { mutableStateOf(0) }
  // 用 ImmutableList（稳定类型），内容不变
  val users = remember { immutableListOf(User("张三"), User("李四")) }

  Column {
    Button(onClick = { clickCount++ }) {
      Text("点击计数：$clickCount")
    }
    UserList(users) // users 是稳定类型，内容没改，会跳过重组
  }
}

这时再点击计数按钮，UserList 和 UserItem 因为参数是稳定类型且值未变，会被 Compose 跳过重组，避免无效性能消耗。

总结：记住 3 个核心点

  1. 可组合项的一生很简单：进入组合 → 可能重组多次 → 退出组合；
  2. 区分“分身”靠两点：调用点（代码里的位置）+ key（唯一标识，列表必用）；
  3. 跳过重组有条件：输入参数是稳定类型 + 值没变化。

掌握这些，就能理解 Compose 为什么高效 : 它只更新该更新的部分，不做无用功。

参考 : 官方文档

Compose系列 四 生命周期
ljjliujunjie123的博客
11-05 3444
本系列是我学习compose过程中，对官方文档的翻译和解读，以及实验性的Demo工程。主要参考官方文档和中文手册 全部的正文内容（Demo工程除外）源自Compose官方文档，个人解读以引用的形式插入。 Compose 官方文档 https://developer.android.google.cn/jetpack/compose Compose 中文手册 https://compose.net.cn/ 本文翻译内容 https://developer.android.google.cn/jetpack/.
Jetpack Compose 生命周期介绍
weixin_44780781的博客
11-21 1122
Jetpack Compose 的生命周期与传统的 View 不同，它主要基于和两个阶段来管理 UI 的创建和更新，同时通过一些工具（如）来处理生命周期事件。提示：以下是本篇文章正文内容，下面案例可供参考Jetpack Compose 的生命周期分为 Composition、Recomposition 和 Disposal。核心工具：LaunchedEffect：处理异步任务，与 UI 生命周期绑定。DisposableEffect：管理资源的初始化和清理。
Android Jetpack Compose学习笔记（二）Compose的状态和生命周期
bugyinyin的博客
07-04 2750
之前我们介绍了Compose编程思想，今天我们来看看Compose的状态和生命周期，先来看看Compose的状态。上接：Android Jetpack Compose学习笔记（一）Compose编程思想先讲一个概念————组合，之前说过可组合函数，而组合用于描述界面，通过运行可组合项来生成，也是树的结构。简单说下Compose的工作流程：在初始组合期间，Compose跟踪为描述界面而调用的可组合项；当应用程序的状态发生变化时，Compose会安排重组；重组过程中会运行可能已更改的可组合项以响应状态变化，然后
告别嵌套地狱：Recompose三大利器简化React组件逻辑
gitblog_00157的博客
08-24 319
### compose的基本概念 compose函数是函数式编程中的组合函数，它接收多个函数作为参数，从右到左依次执行这些函数，并将每个函数的输出作为下一个函数的输入。在Recompose中，compose主要用于组合多个高阶组件，避免了嵌套调用的回调地狱。 ### compose的实现原理 [src/packages/recompose/compose.js](https://link.g...
Android Compose UI状态管理之生命周期
weixin_38754349的博客
09-27 1252
以下内容来自公众号code小生，关注每日干货及时送达一、前言借用官方的回答由于 Compose 是声明式工具集，因此更新它的唯一方法是通过新参数调用同一可组合项。这些参数是界面状态的表现形式。每当状态更新时，都会发生重组。不会像在基于 XML 的命令式视图中那样自动更新。可组合项必须明确获知新状态，才能相应地进行更新。1.1、传统思维什么意思呢可以看一段代码：可以测试到clickable更改...
告别 Activity 生命周期，迎接 Compose 生命周期
虎哥LoveDroid
05-08 2684
作为 Android 应用程序开发人员，您知道管理 Activity 生命周期是构建高质量应用程序的重要组成部分。起初，我对 Compose Lifecycle 持怀疑态度。多年来我一直在使用 Activity Lifecycle，它对我来说一直运行良好。但是在试用了 Compose 之后，我被它让我作为开发人员的生活变得多么轻松而震惊了在 Activity Lifecycle 中，需要管理的生命周期方法非常多，而且很快就会变得复杂起来。
Jetpack Compose系列教程之(16)——Compose生命周期及副作用函数
02-18 1630
此文建议需要了解kotlin的lambda表达式使用和协程基础使用，不然可能会有些阅读困难。Composable 组件都是函数，Composable 函数执行会得到一棵视图树，每一个 Composable 组件对应视图树上的一个节点。
Android Jetpack Compose基础之生命周期-重组
hong_world的博客
03-09 1307
Android Jetpack Compose 基础知识系列
从状态管理到性能优化：全面解析 Android Compose
陆业聪
09-09 5754
本文详细介绍了 Android Compose，一个现代化的 UI 框架，强调其声明式、简洁和可组合性的优势。文章探讨了状态管理、列表处理和性能优化，旨在帮助开发者有效利用 Compose 构建高效的 Android 应用。
【Compose multiplatform教程21】生命周期
b275518834的专栏
12-29 800
在多平台生命周期中使用协程时，请记住该值与该值相关联，默认情况下，该值在桌面目标上可能不可用。默认情况下，Compose Multiplatform 创建的所有可组合项共享相同的生命周期，它们可以订阅其事件、引用生命周期状态等。Compose Multiplatform 提供了一种通用实现，它将原始的 Jetpack Compose 功能扩展到其他平台，并帮助观察通用代码中的生命周期状态。生命周期感知型组件可以对其他组件生命周期状态的变化做出反应，并帮助您生成组织更清晰、通常更轻巧、更易于维护的代码。
Android Jetpack Compose之生命周期与副作用
知识应该共享，创造才应收费
10-11 1789
借助于Kotlin的DSL语言特性，Compose可以很形象地描述UI的视图结构，视图结构对应的是一棵视图树的数据结构，这棵树在Compose中称为Composition,Composition会在Composable初次执行时被创建，当在Composable中访问State时，Compose记录其引用，当State变化时，Composition触发对应的Composable进行重组，更新视图树中的节点，然后达到刷新UI的目的。
Compose 生命周期和副作用
xiangxiongfly
05-08 1055
生命周期 副作用API DisposableEffect SIdeEffect LaunchedEffect rememberCoroutineScope rememberUpdatedState snapshotFlow produceState derivedStateOf
Android | Compose 生命周期和附带效应
345丶
06-08 2013
可组合项 `应该没有附带效应`，但是，如果在对应用状态进行转变时需要使用可组合项。此时你应该使用 Effect API , 以便以可以预测的方式来执行这些附带消息
Composer的生命周期是什么？底层原理是什么？
长风破浪会有时的博客
09-04 121
底层原理是 Composer 通过解析 Composer.json 文件，读取依赖关系并处理依赖关系，利用 Packagist 提供的元数据和镜像，从远程仓库或本地缓存中下载和安装依赖包，并生成 Autoload 文件、Composer.lock 文件和 Phar 包等。在实现上，Composer 是基于 PHP 开发的，利用了 PHP 提供的文件操作和命令行交互等特性，同时使用了各种 PHP 库和工具来解析 JSON、下载文件、解压缩包、处理依赖关系等。
Jetpack Compose 生命周期
移动端开发干货分享
04-08 2156
Compose通过一系列Effects方法实现生命周期函数，类似React的Hooks Api Compose Lifecycle 同样是声明式UI框架，所以Compose的生命周期函数可以与React进行类比 Compose生命周期 说明 对应的React onActive compose函数第一次被渲染到画面 componentWillMount componentDidMo...
活字格低代码平台实现移动端应用（安卓 /iOS）打包的技术方案与实践指南
葡萄城技术团队博客
10-17 588
活字格低代码平台通过"可视化开发+原生级打包"技术，实现安卓/iOS移动应用的快速开发与发布。该平台采用混合架构设计，支持APK/AAB(安卓)和IPA(iOS)格式打包，兼容最新系统版本(安卓15/iOS18)，内置UI自适应组件和安全合规机制。打包流程包含账号准备、参数配置、签名操作和测试分发四个步骤，显著降低移动开发门槛。相比传统开发，活字格可将开发周期缩短60%-80%，并支持热更新功能，已在制造、金融、政务等领域落地数千案例，为企业提供高效的移动数字化解决方案。
Linux进程信号（上）
最新发布
2402_84433929的博客
10-19 1187
本文从生活和技术角度系统介绍了Linux信号机制。信号是进程间异步事件通知的软中断方式，其处理包括忽略、默认动作和自定义捕捉三种。信号产生来源多样：终端按键（如Ctrl+C）、系统命令（kill）、函数调用（kill/raise/abort）、软件条件（alarm/SIGALRM）和硬件异常（除零/SIGFPE）。重点解析了信号处理流程、前台/后台进程区别、core dump原理及可重入函数概念，并通过代码示例演示了信号注册、捕获和处理的完整过程。希望这些内容对大家有所帮助！
Android 对话框 - 对话框全屏显示（设置 Window 属性、使用自定义样式、继承 DialogFragment 实现、继承 Dialog 实现）
weixin_52173250的博客
10-16 970
Android 对话框 - 对话框全屏显示（设置 Window 属性、使用自定义样式、继承 DialogFragment 实现、继承 Dialog 实现）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

氦客

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值