第 10 章 作用域函数、DSL 与 context parameters
本章目标
- 彻底搞清
let/run/with/apply/also的差异,并给出可执行的决策树;- 理解扩展函数的字节码真相:它是静态方法,静态解析,不参与多态;
- 掌握 DSL 设计的核心难题(作用域泄漏)与
@DslMarker的解法;- 深入 📌 Kotlin 2.4 转正的 context parameters:语法、解析规则、显式 context 实参、限制、与依赖注入的关系;
- 学会设计一个自己的类型安全 DSL。
10.1 五个作用域函数:从源码开始
它们的源码总共不到 30 行。读一遍源码,比看十篇博客有用。
// kotlin/libraries/stdlib/src/kotlin/util/Standard.kt
public inline fun <T, R> T.let(block: (T) -> R): R {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
return block(this)
}
public inline fun <R> run(block: () -> R): R {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
return block()
}
public inline fun <T, R> T.run(block: T.() -> R): R {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
return block()
}
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
return receiver.block()
}
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
block()
return this
}
public inline fun <T> T.also(block: (T) -> Unit): T {
contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
block(this)
return this
}
public inline fun <R> R.takeIf(predicate: (R) -> Boolean): R? {
contract { callsInPlace(predicate, InvocationKind.EXACTLY_ONCE); returnsNotNull() implies predicate(this@takeIf) }
return if (predicate(this)) this else null
}
三维对照表
| 函数 | 接收者形式 | Lambda 参数 | 返回值 | 是否扩展 |
|---|---|---|---|---|
let | this(扩展) | it(Lambda 参数) | Lambda 结果 | ✅ |
run(扩展) | this | this(Lambda 接收者) | Lambda 结果 | ✅ |
with | 第一个参数 | this | Lambda 结果 | ❌ 普通函数 |
apply | this | this | 接收者本身 | ✅ |
also | this | it | 接收者本身 | ✅ |
run(无接收者) | 无 | 无 | Lambda 结果 | ❌ |
🔬 记忆法:
Lambda 用 it Lambda 用 this
返回 Lambda 结果 │ let run / with
返回接收者本身 │ also apply
决策树
你需要什么?
│
├─ 对可空对象执行操作,避免 NPE ......................... ?.let { } 或 ?.run { }
│
├─ 把值转换成另一个值(映射).......................... let { }
│
├─ 配置一个刚创建的对象(builder 风格)................ apply { }
│ User().apply { name = "x"; age = 1 }
│
├─ 在链式调用中插入副作用(日志、校验)................. also { }
│ list.filter{...}.also{ log(it) }.map{...}
│
├─ 对一个对象执行一组操作,且要用它的成员 ............... run { } / with(obj) { }
│ with(connection) { setAutoCommit(false); commit() }
│
├─ 执行一段代码块,限定变量作用域 ..................... run { }(无接收者版本)
│ val x = run { val tmp = compute(); tmp * 2 }
│
├─ 条件转可空值 .................................... takeIf { } / takeUnless { }
│
└─ 资源管理 ........................................ use { }(AutoCloseable)
典型用法对照
// ① let:转换 + 处理可空
val length: Int? = name?.let { it.trim().length }
// ② apply:构造并配置(返回对象本身)
val dataSource = HikariDataSource().apply {
jdbcUrl = "jdbc:postgresql://localhost/db"
maximumPoolSize = 20
isAutoCommit = false
}
// ③ also:链式副作用(返回对象本身)
val users = fetchUsers()
.also { logger.info("fetched ${it.size} users") }
.filter { it.active }
.also { logger.info("after filter: ${it.size}") }
// ④ with:对一个对象做一组操作
fun render(conn: Connection) = with(conn) {
autoCommit = false // 直接访问成员,无需 conn.
prepareStatement(SQL).use { it.executeQuery() }
commit()
}
// ⑤ run:限定作用域的代码块 + 计算结果
val config = run {
val raw = loadRaw()
val parsed = parse(raw)
validate(parsed)
parsed // 块的最后一个表达式是返回值
}
// ⑥ run(扩展):对象 + 计算结果
val summary = order.run {
val total = items.sumOf { it.price * it.qty }
"Order $id: $total"
}
// ⑦ takeIf / takeUnless
val port = input.toIntOrNull()?.takeIf { it in 1..65535 }
10.2 作用域函数的六个陷阱
陷阱 1:嵌套时的 this / it 混淆
user?.let { u ->
orders?.let { o ->
// 这里 it 是 orders,u 是 user
// 如果都用了隐式 it,就完全分不清了
}
}
🚀 规则:嵌套超过一层,必须显式命名。
// ❌ 不可读
user?.let { it.orders?.let { it.filter { it.active } } }
// ✅ 显式命名
user?.let { user ->
user.orders?.let { orders ->
orders.filter { it.active } // 最内层的 it 是 order,作用域清晰
}
}
// ✅✅ 更好:避免嵌套
val active = user?.orders?.filter { it.active }
陷阱 2:?.let 的返回值也是可空的
val x: Int? = name?.let { it.length } // Int?,不是 Int!
val y: Int = name?.let { it.length } ?: 0 // 需要 Elvis
⚠️ 一个隐蔽的坑:Lambda 返回 Unit 时
val r = name?.let { println(it) } // r 的类型是 Unit?,不是 Unit
陷阱 3:apply 的最后一个表达式被忽略
val sb = StringBuilder().apply {
append("a")
append("b")
toString() // ← 这个值被丢弃了!apply 返回 StringBuilder
}
println(sb) // "ab"(StringBuilder 的 toString)
⚠️ 新手常写 apply { ... ; someValue } 期望返回 someValue——apply 永远返回接收者。要返回 Lambda 结果用 run。
陷阱 4:also 与 apply 混用导致链式调用返回错误的值
// ❌ 意图是"过滤后返回 list",但 apply 返回的是 this
val result = list.apply { filter { it > 0 } } // result 还是原 list!filter 结果被丢弃
// ✅
val result = list.also { log(it) }.filter { it > 0 }
陷阱 5:多线程下的 ?.let 是安全的,但 if (x != null) x.foo() 不是
class Holder { @Volatile var name: String? = "a" }
val h = Holder()
// ❌ 竞态
if (h.name != null) {
println(h.name!!.length) // 另一线程可能已置 null → NPE
}
// ✅ 安全:let 把值传给了 Lambda 参数(局部不可变)
h.name?.let { println(it.length) }
🔬 原理:?.let 编译为
aload h; getfield name; dup; ifnull L1; astore tmp; ... invokeinterface let(tmp) ...
dup + astore 把值固定在栈上/局部变量,之后不再读字段。而 if (x != null) x.foo() 会读两次字段,中间可能被修改。
这也是智能转换对 var 属性失效的根本原因(第 6 章)。
陷阱 6:作用域函数滥用导致可读性下降
// ❌ 为了"函数式"而函数式
val result = input
?.let { it.trim() }
?.let { it.lowercase() }
?.let { it.replace(" ", "_") }
?.let { if (it.length > 20) it.take(20) else it }
// ✅ 直接用中间变量,更清晰
val trimmed = input?.trim()
val normalized = trimmed?.lowercase()?.replace(" ", "_")
val result = normalized?.let { if (it.length > 20) it.take(20) else it }
// 或
val result = normalized?.take(20)
🚀 准则:作用域函数应该减少认知负担,而不是增加。如果一个链需要读者回头找 it 指什么,就该拆开。
10.3 扩展函数:优雅与陷阱并存
字节码真相
package book.ch10
fun String.shout(): String = uppercase() + "!!!"
val String.lastChar: Char get() = this[length - 1]
fun main() { println("hi".shout()) }
public final class book.ch10.ExtensionsKt {
public static final String shout(@NotNull String $this$shout) {
// Intrinsics.checkNotNullParameter($this$shout, "$this$shout");
// ... uppercase() + "!!!"
}
public static final char getLastChar(@NotNull String $this$lastChar) { ... }
public static final void main() { ... }
}
🔬 五个关键事实:
- 扩展函数编译为静态方法,接收者是第一个参数(参数名
$this$函数名); - 它们是静态解析的——编译期根据声明类型决定调用哪个,不参与多态;
- 扩展属性没有 backing field(所以不能有初始化器,只能用 getter/setter);
- Java 侧调用方式:
ExtensionsKt.shout("hi"); - 成员函数优先于扩展函数(同签名时)。
⚠️ 静态解析的陷阱
open class Animal
class Dog : Animal()
fun Animal.speak() = "animal sound"
fun Dog.speak() = "woof"
fun test(a: Animal) = a.speak()
fun main() {
val d: Dog = Dog()
println(test(d)) // "animal sound" ← 不是 "woof"!
}
🔬 原因:编译 test 时,a 的静态类型是 Animal,所以生成 invokestatic ExtensionsKt.speak(LAnimal;)。运行时 a 指向 Dog 也无所谓——扩展函数不是虚方法。
对比:如果是成员函数,结果会是 "woof"(虚方法分派)。
🚀 这是扩展函数最重要的语义限制:
- ✅ 用于"给已有类型加工具方法"(
String.shout())——语义正确; - ❌ 不要用于"多态行为"——应该用接口 + 成员函数。
扩展函数的解析优先级
class Foo { fun bar() = "member" }
fun Foo.bar() = "extension"
Foo().bar() // "member" ← 成员总是赢
⚠️ 但如果签名不同(参数类型/可空性),扩展函数可能被选中:
class Foo { fun bar(s: String) = "member" }
fun Foo.bar(s: Any?) = "extension"
Foo().bar("x") // "member"(String 更具体)
Foo().bar(42) // "extension"
🚀 准则:不要给已有类定义与成员同名的扩展函数。这会造成极大的困惑。
可空接收者的扩展函数
fun String?.orDefault(default: String): String = this ?: default
val s: String? = null
println(s.orDefault("x")) // ✅ 可以在 null 上调用!
🔬 实现:接收者类型是 String?,所以不生成 checkNotNullParameter。函数内部必须自己处理 null。
标准库大量使用这个技巧:
public inline fun CharSequence?.isNullOrBlank(): Boolean {
contract { returns(false) implies (this@isNullOrBlank != null) }
return this == null || this.isBlank()
}
public inline fun <T> Iterable<T>?.orEmpty(): List<T> = this ?: emptyList()
扩展函数 vs 成员函数:怎么选
| 场景 | 选择 | 理由 |
|---|---|---|
| 你能修改目标类 | 成员函数 | 支持多态、可访问 private、IDE 发现性更好 |
| 目标类是第三方/JDK 类 | 扩展函数 | 唯一选择 |
| 需要多态行为 | 成员函数 / 接口 | 扩展函数静态解析 |
| 纯工具函数、与类状态无关 | 扩展函数 | 更好的调用语法,不污染类 |
| 需要访问 private 状态 | 成员函数(或 @PublishedApi internal) | 扩展函数无法访问 private |
| DSL 内部 | 扩展函数 + 接收者 | 见 10.5 |
10.4 DSL:类型安全构建器
一个完整的 HTML DSL
package book.ch10.html
@DslMarker
annotation class HtmlDsl
@HtmlDsl
abstract class Tag(val name: String) {
private val children = mutableListOf<Any>() // Tag 或 String
fun text(content: String) { children += content }
protected fun <T : Tag> initTag(tag: T, init: T.() -> Unit): T {
tag.init()
children += tag
return tag
}
override fun toString(): String = buildString { render(this, 0) }
private fun render(sb: StringBuilder, depth: Int) {
sb.append(" ".repeat(depth)).append('<').append(name).append(">\n")
children.forEach {
when (it) {
is String -> sb.append(" ".repeat(depth + 1)).append(it).append('\n')
is Tag -> it.render(sb, depth + 1)
}
}
sb.append(" ".repeat(depth)).append("</").append(name).append(">\n")
}
}
class HTML : Tag("html") {
fun head(init: Head.() -> Unit) = initTag(Head(), init)
fun body(init: Body.() -> Unit) = initTag(Body(), init)
}
class Head : Tag("head") {
fun title(init: Title.() -> Unit) = initTag(Title(), init)
}
class Title : Tag("title")
class Body : Tag("body") {
fun h1(init: H1.() -> Unit) = initTag(H1(), init)
fun p(init: P.() -> Unit) = initTag(P(), init)
fun ul(init: Ul.() -> Unit) = initTag(Ul(), init)
}
class H1 : Tag("h1")
class P : Tag("p")
class Ul : Tag("ul") {
fun li(init: Li.() -> Unit) = initTag(Li(), init)
}
class Li : Tag("li")
fun html(init: HTML.() -> Unit): HTML = HTML().apply(init)
使用:
val page = html {
head { title { text("Kotlin DSL") } }
body {
h1 { text("Hello") }
ul {
listOf(1, 2, 3).forEach { li { text("Item $it") } }
}
p { text("这是类型安全的 HTML") }
}
}
println(page)
🔬 这个 DSL 的四个魔法:
- Lambda 带接收者(
T.() -> Unit):让 Lambda 体内可以直接调用head、body等方法(它们是HTML的成员); apply(init):调用后立即返回对象,形成"构造 + 配置"的一体化语法;@DslMarker:限制隐式接收者的可见范围(见下);- 类型即约束:
title只能在head里调用,li只能在ul里调用——编译期保证结构合法。
@DslMarker 解决什么问题:作用域泄漏
没有 @DslMarker 时:
html {
body {
// 这里 this 是 Body
// 但 HTML 的成员(head、body)也仍然可见!因为外层接收者还在作用域里
head { } // ⚠️ 编译通过,但生成非法 HTML(head 嵌在 body 里)
}
}
加了 @DslMarker(同一个 marker 注解的接收者,只有最内层可见):
html {
body {
head { } // ❌ 编译错误:Cannot access 'head' ... it is hidden by the nearest receiver
}
}
🔬 规则:@DslMarker 标注的注解,会让编译器只允许最内层的、被同一 marker 标注的接收者隐式访问。外层接收者仍然可以通过 this@html 显式访问。
🚀 这是设计 DSL 的必备工具。Gradle Kotlin DSL、Ktor、Compose、 kotlinx.html 都用了它。
DSL 设计的六条准则
- 必须有
@DslMarker,防止作用域泄漏; - Lambda 参数用接收者形式(
T.() -> Unit)而非普通参数((T) -> Unit),才能省略it.; - 入口函数返回构建好的对象(
fun html(...): HTML),而非Unit; - 提供
@HtmlDsl之类的注解让 IDE 高亮"DSL 上下文"(IntelliJ 会显示特殊缩进与颜色); - 避免在 DSL 里暴露可变状态(
children应该是 private); - 考虑
inline:小型 DSL 函数加inline可以消除 Lambda 分配,但会失去@DslMarker之外的调试便利。
⚠️ DSL 的代价:
- 每个层级都分配对象(
HTML、Head、Title、Body…); - 调试困难(Lambda 嵌套,栈很深);
- 对新手不友好(IDE 补全会列出大量成员,难以发现"哪个才是当前上下文可用的")。
🚀 判断标准:DSL 适合"结构复杂、重复度高、需要类型安全"的配置场景(HTML、SQL、Gradle、路由、状态机)。不适合"只写一次、结构简单"的场景。
10.5 📌 Context Parameters(Kotlin 2.2 预览 → 2.4 稳定)
这是 Kotlin 近年最重要的语言特性之一,用于声明"函数隐式依赖的上下文"。
它取代了什么
- 取代 context receivers(旧的实验特性,
context(UserService)不带名字); - 部分取代"到处传参数"的模式;
- 部分取代 DI 框架在某些场景的作用。
核心区别:必须用名字访问
// 旧的 context receivers(已废弃):上下文被当作接收者,隐式可用
context(UserService)
fun outputMessage(msg: String) {
log("Log: $msg") // ← 直接调用,不知道来自哪里 😕
}
// 📌 context parameters(2.4 稳定):有名字,必须显式
context(users: UserService)
fun outputMessage(msg: String) {
users.log("Log: $msg") // ← 明确知道用的是 users ✅
}
🔬 为什么这个改变重要:context receivers 的隐式性带来了与 DSL 接收者完全一样的作用域泄漏问题——你不知道 log 来自哪个上下文。context parameters 通过强制命名解决了这个问题,代价是多打几个字。
完整语法
interface UserService {
fun log(message: String)
fun findUserById(id: Int): String
}
// ① 函数的 context parameter
context(users: UserService)
fun outputMessage(message: String) {
users.log("Log: $message")
}
// ② 属性的 context parameter(📌 不能有 backing field 或初始化器)
context(users: UserService)
val firstUser: String
get() = users.findUserById(1)
// ③ 多个 context parameters
context(clock: Clock, events: EventPublisher, currentUser: User)
fun confirmOrder(orderId: String) {
events.publish(OrderConfirmed(orderId, clock.now(), currentUser.id))
}
// ④ 匿名 context parameter(用 _ 命名)
context(_: UserService)
fun logWelcome() {
outputMessage("Welcome!") // 匿名参数仍能满足被调函数的上下文需求
contextOf<UserService>().log("Hi!") // 需要显式访问时用 contextOf<T>()
}
如何提供上下文
fun main() {
val users = object : UserService {
override fun log(message: String) = println(message)
override fun findUserById(id: Int) = "User $id"
}
// ① 用 context() 函数建立一个作用域
context(users) {
outputMessage("Looking up the first user")
println(firstUser) // User 1
}
// ② 提供一个作用域里的多个上下文值
context(clock, events, user) {
confirmOrder("ord-1")
}
// ③ 如果当前类本身实现了该接口,成员函数可以直接调用
}
解析规则
Kotlin 按类型在调用点的作用域中查找匹配的上下文值:
context(users: UserService)
fun outputMessage(message: String) { users.log(message) }
fun main() {
val serviceA = object : UserService { override fun log(m: String) = println("A: $m") }
val serviceB = object : UserService { override fun log(m: String) = println("B: $m") }
context(serviceA, serviceB) {
outputMessage("...") // ❌ 编译错误:歧义!两个值都匹配 UserService
}
}
📌 显式 context 实参(2.4 实验性)
解决歧义,同时减少嵌套:
class EmailSender
class SmsSender
context(emailSender: EmailSender)
fun sendNotification() = println("Sent email notification")
context(smsSender: SmsSender)
fun sendNotification() = println("Sent SMS notification")
context(defaultEmail: EmailSender, defaultSms: SmsSender)
fun notifyUser() {
sendNotification(emailSender = defaultEmail) // ✅ 选中 email 版本
sendNotification(smsSender = defaultSms) // ✅ 选中 sms 版本
}
开启方式:
compilerOptions { freeCompilerArgs.add("-Xexplicit-context-arguments") }
🚀 官方建议:
- 单次调用 → 用显式 context 实参(更易读);
- 多次调用共享上下文 → 用
context()函数(减少重复)。
当前的限制
📌 截至 Kotlin 2.4,以下仍不支持:
- 构造器不能声明 context parameters;
- 带 context parameters 的属性不能有 backing field 或初始化器(只能用自定义 getter);
- 带 context parameters 的属性不能用委托(
by lazy等); - callable references(
::f)对 context parameters 的支持仍在推进中(2.4 明确排除)。
实战场景
场景 1:横切关注点(日志、指标、追踪)
interface Tracer { fun span(name: String, block: () -> Unit) }
context(tracer: Tracer)
fun processPayment(id: String) {
tracer.span("processPayment") {
validate(id)
charge(id)
}
}
// 使用
context(openTelemetryTracer) {
processPayment("pay-1")
}
对比传统方案:
- 传参数:每个函数都要加
tracer: Tracer参数,污染签名; - ThreadLocal:虚拟线程下有问题(第 34 章),且不可见;
- DI 框架:需要框架支持,且是运行时解析;
- context parameters:编译期解析、签名干净、显式命名、作用域清晰。
场景 2:领域服务的"执行环境"
data class OrderContext(val clock: Clock, val user: User, val events: MutableList<DomainEvent>)
context(ctx: OrderContext)
fun Order.confirm() {
require(status == Status.PENDING)
copy(status = Status.CONFIRMED, confirmedAt = ctx.clock.instant())
.also { ctx.events += OrderConfirmed(it.id) }
}
这是 2026 年 Kotlin 社区讨论最热的模式:把"执行环境"作为 context,让领域实体保持纯粹(不依赖框架、不依赖注入)。
场景 3:替代部分 DI
context(repo: UserRepository, mailer: Mailer)
suspend fun register(email: String) {
val user = repo.create(email)
mailer.sendWelcome(user)
}
⚠️ 但不要用它替代 DI 框架:
- context parameters 是编译期的,无法做运行时的作用域管理(request scope、singleton 生命周期);
- 无法做 AOP(事务、缓存);
- 无法做配置注入(
@Value)。
🚀 正确的定位:context parameters 用于"函数级的执行上下文",DI 框架用于"应用级的对象生命周期管理"。两者互补,不是替代。
Context parameters vs 其他方案对照
| 方案 | 编译期检查 | 作用域清晰 | 支持多上下文 | 运行时开销 | 虚拟线程友好 | 适合场景 |
|---|---|---|---|---|---|---|
| 显式参数 | ✅ | ✅ | ✅(冗长) | 零 | ✅ | 少量依赖 |
| 成员属性(构造注入) | ✅ | ✅ | ✅ | 零 | ✅ | 类的长期依赖 |
| 扩展接收者(DSL) | ✅ | 🔶(作用域泄漏) | ❌(单接收者) | 零 | ✅ | DSL |
ThreadLocal | ❌ | ❌ | ✅ | 低 | ❌(虚拟线程下有问题) | 遗留代码 |
ScopedValue(JEP 506) | ❌ | ✅ | ✅ | 低 | ✅ | Java 21+ 的上下文传递 |
协程 CoroutineContext | 🔶 | ✅ | ✅ | 低 | ✅ | 协程内的上下文(如 coroutineContext[Transaction]) |
| 📌 context parameters | ✅ | ✅ | ✅ | 零 | ✅ | 函数级执行上下文 |
10.6 📌 集合字面量(2.4 实验)
// 传统
val list = listOf(1, 2, 3)
val map = mapOf("a" to 1)
// 📌 2.4 实验性
val list = [1, 2, 3]
val set = [1, 2, 3] // 根据目标类型推断是 List 还是 Set
val map = ["a": 1, "b": 2]
开启:
compilerOptions { freeCompilerArgs.add("-Xcollection-literals") }
⚠️ 评估:
- 收益:更简洁,与其他语言一致;
- 风险:
[]与数组、索引访问的语义可能混淆;类型推断依赖上下文(可能需要显式类型标注)。
🚀 建议:2.4–2.5 期间保持观望,等特性稳定后再在团队中推广。语言特性的采纳应该有节奏,不必追每一个实验特性。
10.7 性能视角:作用域函数与 DSL 的成本
🧪 实验 10-1:作用域函数有开销吗?
@Benchmark fun withLet(x: String): Int = x.let { it.length }
@Benchmark fun direct(x: String): Int = x.length
结果:几乎相同(差异在测量噪声内)。因为 let 是 inline,Lambda 体被复制到调用点,没有对象分配、没有间接调用。
🧪 实验 10-2:DSL 的分配成本
@Benchmark fun buildHtml(): String = html {
head { title { text("x") } }
body { p { text("y") } }
}.toString()
用 -prof gc 观察:每次调用分配 6–8 个对象(HTML、Head、Title、Body、P、各个 children List)。
⚠️ DSL 不是零成本的。它换取的是类型安全与可读性。在高频调用的路径上(如每秒渲染上万次),应该:
- 缓存构建结果(如果结构固定);
- 用
StringBuilder直接拼接; - 或用模板引擎。
🚀 判断标准:DSL 用于"配置期"(启动时、构建时)是完美的;用于"请求期"的热路径需要衡量。 Gradle Kotlin DSL 就是典型的"配置期 DSL"——构建脚本只执行一次,可读性远比性能重要。
10.8 本章小结
- 五个作用域函数只有三个维度的差异:Lambda 用
it还是this、返回 Lambda 结果还是接收者、是否扩展函数。读一遍源码(30 行)就永远记住了。 - 它们都是
inline+ 带callsInPlace(EXACTLY_ONCE)契约,所以零分配、且支持在 Lambda 里初始化val。 - 六个陷阱:嵌套时
it混淆、?.let返回可空、apply忽略最后表达式、also/apply混用、多线程下?.let安全而if != null不安全、过度链式降低可读性。 - 扩展函数是静态方法,静态解析,不参与多态。这是它最重要的语义限制——不要用它实现多态行为。
- 扩展属性没有 backing field,只能用 getter/setter 计算。
- 成员函数优先于扩展函数(同签名时)。
- DSL 的三大支柱:Lambda 带接收者 +
apply+@DslMarker。@DslMarker是防止作用域泄漏的必备工具。 - 📌 context parameters(2.4 稳定) 用"命名的隐式依赖"取代了 context receivers:按类型解析、
context()函数提供作用域、contextOf<T>()取匿名值、显式 context 实参解决歧义(实验)。定位是"函数级执行上下文",不是 DI 框架的替代品。 - 限制:构造器不能声明 context parameters;带 context 的属性不能有 backing field/初始化器/委托。
10.9 练习题
10-1. 为下面每个场景选择最合适的作用域函数,并说明理由。
// a) 创建并配置一个 HttpClient
// b) 在链式调用中打印中间结果
// c) 把 String? 转成 Int?(去掉空白后解析)
// d) 对 Connection 执行一组操作(setAutoCommit/prepareStatement/commit)
// e) 限定一段计算中临时变量的作用域
// f) 把不符合条件的值转成 null
答案要点
a) apply:配置对象后返回对象本身。
val client = HttpClient(CIO).apply {
install(ContentNegotiation) { json() }
engine { requestTimeout = 5000 }
}
b) also:副作用 + 返回接收者,不打断链。
val result = data.filter{...}.also { log("filtered: ${it.size}") }.map{...}
c) let:转换值,处理可空。
val n: Int? = s?.trim()?.let { it.toIntOrNull() }
d) with(或 run):对已有对象执行一组操作,直接访问成员。
with(conn) { autoCommit = false; prepareStatement(SQL).use { it.executeQuery() }; commit() }
如果 conn 可空,用 conn?.run { ... }。
e) run(无接收者版本):限定作用域,返回值。
val total = run { val base = compute(); val tax = base * 0.1; base + tax }
f) takeIf / takeUnless:
val port = input.toIntOrNull()?.takeIf { it in 1..65535 }
10-2. 下面的代码有什么问题?
open class Base
class Derived : Base()
fun Base.describe() = "base"
fun Derived.describe() = "derived"
fun printIt(b: Base) = println(b.describe())
fun main() {
printIt(Derived())
}
答案要点
输出 "base",不是 "derived"。
原因:扩展函数是静态解析的。printIt 的参数 b 静态类型是 Base,编译器生成 invokestatic ExtensionsKt.describe(LBase;)。运行时 b 实际是 Derived 也不影响——扩展函数不是虚方法,不参与多态分派。
如果 describe 是成员函数,会输出 "derived"(invokevirtual 虚分派)。
教训:
- 扩展函数适合"给类型加工具方法",不适合"表达多态行为";
- 需要多态时用接口 + 成员函数;
- 这是面试高频题,也是真实 bug 源(尤其是当有人给基类和子类都定义了同名扩展函数时)。
10-3.(🧪 动手)实现一个类型安全的 SQL 构建 DSL,要求:
select("id", "name").from("users").where { "age" gt 18 }.orderBy("name")能编译;from之前不能调用where(类型系统保证);- 用
@DslMarker防止作用域泄漏。
参考答案骨架
@DslMarker annotation class SqlDsl
@SqlDsl class SelectBuilder(private val cols: List<String>) {
fun from(table: String) = FromBuilder(cols, table)
}
@SqlDsl class FromBuilder(private val cols: List<String>, private val table: String) {
private val conditions = mutableListOf<String>()
private var orderByCol: String? = null
fun where(block: WhereScope.() -> Unit) = apply {
WhereScope(conditions).block()
}
fun orderBy(col: String) = apply { orderByCol = col }
fun build(): String = buildString {
append("SELECT ").append(cols.joinToString()).append(" FROM ").append(table)
if (conditions.isNotEmpty()) append(" WHERE ").append(conditions.joinToString(" AND "))
orderByCol?.let { append(" ORDER BY ").append(it) }
}
}
@SqlDsl class WhereScope(private val out: MutableList<String>) {
infix fun String.gt(v: Int) { out += "$this > $v" }
infix fun String.eq(v: Any?) { out += "$this = ${quote(v)}" }
private fun quote(v: Any?) = when (v) {
null -> "NULL"; is Number -> v.toString(); else -> "'$v'"
}
}
fun select(vararg cols: String) = SelectBuilder(cols.toList())
fun main() {
val sql = select("id", "name").from("users")
.where { "age" gt 18; "status" eq "active" }
.orderBy("name")
.build()
println(sql)
}
关键设计点:
- 类型即状态机:
SelectBuilder只有from,FromBuilder才有where/orderBy→ 编译期保证调用顺序; @DslMarker防止where { }内部误调用外层的from;infix函数 让"age" gt 18读起来像自然语言;- ⚠️ 这个示例用字符串拼接,生产环境必须用参数化查询(
?+ 参数列表)防止 SQL 注入。真实实现应该收集参数而非拼值。
10-4. 用 context parameters 重构下面的代码,消除参数传递的噪音。
interface AuditLog { fun record(action: String, user: String) }
interface Clock { fun now(): Instant }
fun createOrder(items: List<Item>, user: User, clock: Clock, audit: AuditLog): Order {
val order = Order(items, user.id, clock.now())
audit.record("createOrder:${order.id}", user.name)
return order
}
fun cancelOrder(order: Order, user: User, clock: Clock, audit: AuditLog) { ... }
fun shipOrder(order: Order, user: User, clock: Clock, audit: AuditLog) { ... }
参考答案
context(clock: Clock, audit: AuditLog, user: User)
fun createOrder(items: List<Item>): Order {
val order = Order(items, user.id, clock.now())
audit.record("createOrder:${order.id}", user.name)
return order
}
context(clock: Clock, audit: AuditLog, user: User)
fun cancelOrder(order: Order) { ... }
context(clock: Clock, audit: AuditLog, user: User)
fun shipOrder(order: Order) { ... }
// 调用侧:一次建立上下文,多个调用共享
fun handleRequest(req: Request, clock: Clock, audit: AuditLog, user: User) =
context(clock, audit, user) {
val order = createOrder(req.items)
if (req.express) shipOrder(order) else cancelOrder(order)
}
收益:
- 业务函数的签名只剩真正的业务参数(
items、order),基础设施依赖隐式提供; - 类型系统保证:忘记提供上下文会编译错误(不像
ThreadLocal会运行时 NPE); - 作用域清晰:
context(...) { }块之外无法调用这些函数; - 零运行时开销:context parameters 在编译期解析,不产生任何对象或查找。
注意事项:
- 📌 构造器不能声明 context parameters,所以
Order的构造仍需显式传参; - 如果三个上下文经常一起出现,可以定义一个聚合类型
interface OrderContext { val clock: Clock; val audit: AuditLog; val user: User },然后context(ctx: OrderContext)——减少上下文数量,提升可读性。
10-5. @DslMarker 的具体规则是什么?外层接收者还能访问吗?
答案要点
规则:被同一个 @DslMarker 注解标注的多个隐式接收者中,只有最内层的可以被隐式访问。外层的被"隐藏",直接调用会编译错误(INAPPLICABLE_JVM_NAME / HIDDEN_FROM_RESOLUTION 类错误)。
外层仍可显式访问:用限定 this 语法
html { // this@html
body { // this@body
// head { } // ❌ 被 @HtmlDsl 隐藏
this@html.head { } // ✅ 显式访问外层接收者
}
}
多个不同 marker 互不影响:如果 DSL A 用 @MarkerA,DSL B 用 @MarkerB,嵌套时两者的接收者都可见(因为 marker 不同)。这允许"在 HTML DSL 里嵌入 SQL DSL"这类组合。
为什么需要它:没有 @DslMarker 时,嵌套 DSL 的内层可以调用外层的所有方法,产生结构非法但编译通过的代码(如 <body><head/></body>)。这是类型安全 DSL 的最后一块拼图。
10.10 面试题精选
Q1:let、run、with、apply、also 的区别?如何记忆?
答题框架:给出三维对照表(见 10.1),并用"2×2 矩阵 + with/run 特例"的记忆法。再各举一个典型场景。加分:提到它们都是 inline + callsInPlace(EXACTLY_ONCE) 契约,所以零分配且支持在 Lambda 里初始化 val;提到 takeIf/takeUnless/use 是同一家族。
Q2:Kotlin 的扩展函数是怎么实现的?它和成员函数有什么区别?
答题框架:
- 实现:编译为静态方法,接收者作为第一个参数(
$this$name),放在文件类(XxxKt)或@JvmName指定的类里。 - 区别(5 条):
- 静态解析 vs 虚分派:扩展函数按静态类型选择,不参与多态;成员函数走 vtable;
- 访问权限:扩展函数无法访问 private/protected 成员;
- 优先级:同签名时成员函数优先;
- 存储:扩展属性没有 backing field(不能保存状态);
- Java 互操作:Java 侧只能以静态方法形式调用。
- 适用场景:给不可修改的类型(JDK/第三方)加能力;纯工具函数;DSL 接收者。
- 不适用:需要多态的行为;需要访问内部状态;需要被子类重写。
Q3:什么是 @DslMarker?为什么设计 DSL 需要它?
见 10.4 与练习 10-5。答题要点:作用域泄漏问题 → 只允许最内层同 marker 接收者隐式访问 → 外层可用 this@label 显式访问 → 不同 marker 互不干扰。
Q4:Kotlin 2.4 的 context parameters 是什么?它能替代依赖注入框架吗?
答题框架:
- 是什么:用
context(name: Type)声明函数的隐式依赖,调用时用context(value) { }建立作用域,或用 📌 显式 context 实参(实验)。取代了旧的 context receivers,关键改进是必须用名字访问(避免隐式性带来的困惑)。 - 解析规则:按类型在调用点作用域查找;多个匹配 → 歧义错误(可用显式实参解决)。
- 限制:构造器不能声明;带 context 的属性不能有 backing field/初始化器/委托;callable references 支持未完成。
- 能替代 DI 吗?不能,是互补:
- context parameters 是编译期机制,零运行时开销,适合"函数级执行上下文"(Clock、Tracer、CurrentUser、EventPublisher);
- DI 框架(Spring/Koin)管理对象生命周期(singleton/request scope)、AOP(事务/缓存)、配置注入、运行时装配——这些 context parameters 做不到。
- 最佳实践:用 DI 框架管理长期依赖(Repository、Service),用 context parameters 传递请求级的执行上下文。
- 对比其他方案:优于
ThreadLocal(编译期检查、虚拟线程友好、作用域清晰);优于"到处传参数"(签名干净);与协程CoroutineContext互补(后者是运行时的、动态的)。
下一章预告:第 11 章《类与属性:构造顺序、backing field 与显式 backing field》——Kotlin 的属性系统远比"getter/setter 语法糖"复杂。我们会讲:主构造器与 init 块的精确执行顺序(一个真实的初始化 bug)、by lazy 与 Delegates.observable 的实现、📌 显式 backing field(2.3 引入、2.4 稳定) 解决了什么长期痛点、以及属性访问在字节码层面的所有细节。