Kotlin与Java虚拟机十:作用域函数、DSL 与 context parameters

25 阅读11分钟

第 10 章 作用域函数、DSL 与 context parameters

本章目标

  1. 彻底搞清 let/run/with/apply/also 的差异,并给出可执行的决策树;
  2. 理解扩展函数的字节码真相:它是静态方法,静态解析,不参与多态;
  3. 掌握 DSL 设计的核心难题(作用域泄漏)与 @DslMarker 的解法;
  4. 深入 📌 Kotlin 2.4 转正的 context parameters:语法、解析规则、显式 context 实参、限制、与依赖注入的关系;
  5. 学会设计一个自己的类型安全 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 参数返回值是否扩展
letthis(扩展)it(Lambda 参数)Lambda 结果✅
run(扩展)thisthis(Lambda 接收者)Lambda 结果✅
with第一个参数thisLambda 结果❌ 普通函数
applythisthis接收者本身✅
alsothisit接收者本身✅
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() { ... }
}

🔬 五个关键事实:

  1. 扩展函数编译为静态方法,接收者是第一个参数(参数名 $this$函数名);
  2. 它们是静态解析的——编译期根据声明类型决定调用哪个,不参与多态;
  3. 扩展属性没有 backing field(所以不能有初始化器,只能用 getter/setter);
  4. Java 侧调用方式:ExtensionsKt.shout("hi");
  5. 成员函数优先于扩展函数(同签名时)。

⚠️ 静态解析的陷阱

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 的四个魔法:

  1. Lambda 带接收者(T.() -> Unit):让 Lambda 体内可以直接调用 head、body 等方法(它们是 HTML 的成员);
  2. apply(init):调用后立即返回对象,形成"构造 + 配置"的一体化语法;
  3. @DslMarker:限制隐式接收者的可见范围(见下);
  4. 类型即约束: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 设计的六条准则

  1. 必须有 @DslMarker,防止作用域泄漏;
  2. Lambda 参数用接收者形式(T.() -> Unit)而非普通参数((T) -> Unit),才能省略 it.;
  3. 入口函数返回构建好的对象(fun html(...): HTML),而非 Unit;
  4. 提供 @HtmlDsl 之类的注解让 IDE 高亮"DSL 上下文"(IntelliJ 会显示特殊缩进与颜色);
  5. 避免在 DSL 里暴露可变状态(children 应该是 private);
  6. 考虑 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,以下仍不支持:

  1. 构造器不能声明 context parameters;
  2. 带 context parameters 的属性不能有 backing field 或初始化器(只能用自定义 getter);
  3. 带 context parameters 的属性不能用委托(by lazy 等);
  4. 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 不是零成本的。它换取的是类型安全与可读性。在高频调用的路径上(如每秒渲染上万次),应该:

  1. 缓存构建结果(如果结构固定);
  2. 用 StringBuilder 直接拼接;
  3. 或用模板引擎。

🚀 判断标准:DSL 用于"配置期"(启动时、构建时)是完美的;用于"请求期"的热路径需要衡量。 Gradle Kotlin DSL 就是典型的"配置期 DSL"——构建脚本只执行一次,可读性远比性能重要。


10.8 本章小结

  1. 五个作用域函数只有三个维度的差异:Lambda 用 it 还是 this、返回 Lambda 结果还是接收者、是否扩展函数。读一遍源码(30 行)就永远记住了。
  2. 它们都是 inline + 带 callsInPlace(EXACTLY_ONCE) 契约,所以零分配、且支持在 Lambda 里初始化 val。
  3. 六个陷阱:嵌套时 it 混淆、?.let 返回可空、apply 忽略最后表达式、also/apply 混用、多线程下 ?.let 安全而 if != null 不安全、过度链式降低可读性。
  4. 扩展函数是静态方法,静态解析,不参与多态。这是它最重要的语义限制——不要用它实现多态行为。
  5. 扩展属性没有 backing field,只能用 getter/setter 计算。
  6. 成员函数优先于扩展函数(同签名时)。
  7. DSL 的三大支柱:Lambda 带接收者 + apply + @DslMarker。@DslMarker 是防止作用域泄漏的必备工具。
  8. 📌 context parameters(2.4 稳定) 用"命名的隐式依赖"取代了 context receivers:按类型解析、context() 函数提供作用域、contextOf<T>() 取匿名值、显式 context 实参解决歧义(实验)。定位是"函数级执行上下文",不是 DI 框架的替代品。
  9. 限制:构造器不能声明 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 虚分派)。

教训:

  1. 扩展函数适合"给类型加工具方法",不适合"表达多态行为";
  2. 需要多态时用接口 + 成员函数;
  3. 这是面试高频题,也是真实 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)
}

关键设计点:

  1. 类型即状态机:SelectBuilder 只有 from,FromBuilder 才有 where/orderBy → 编译期保证调用顺序;
  2. @DslMarker 防止 where { } 内部误调用外层的 from;
  3. infix 函数 让 "age" gt 18 读起来像自然语言;
  4. ⚠️ 这个示例用字符串拼接,生产环境必须用参数化查询(? + 参数列表)防止 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)
    }

收益:

  1. 业务函数的签名只剩真正的业务参数(items、order),基础设施依赖隐式提供;
  2. 类型系统保证:忘记提供上下文会编译错误(不像 ThreadLocal 会运行时 NPE);
  3. 作用域清晰:context(...) { } 块之外无法调用这些函数;
  4. 零运行时开销: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 的扩展函数是怎么实现的?它和成员函数有什么区别?

答题框架:

  1. 实现:编译为静态方法,接收者作为第一个参数($this$name),放在文件类(XxxKt)或 @JvmName 指定的类里。
  2. 区别(5 条):
    • 静态解析 vs 虚分派:扩展函数按静态类型选择,不参与多态;成员函数走 vtable;
    • 访问权限:扩展函数无法访问 private/protected 成员;
    • 优先级:同签名时成员函数优先;
    • 存储:扩展属性没有 backing field(不能保存状态);
    • Java 互操作:Java 侧只能以静态方法形式调用。
  3. 适用场景:给不可修改的类型(JDK/第三方)加能力;纯工具函数;DSL 接收者。
  4. 不适用:需要多态的行为;需要访问内部状态;需要被子类重写。

Q3:什么是 @DslMarker?为什么设计 DSL 需要它?

见 10.4 与练习 10-5。答题要点:作用域泄漏问题 → 只允许最内层同 marker 接收者隐式访问 → 外层可用 this@label 显式访问 → 不同 marker 互不干扰。

Q4:Kotlin 2.4 的 context parameters 是什么?它能替代依赖注入框架吗?

答题框架:

  1. 是什么:用 context(name: Type) 声明函数的隐式依赖,调用时用 context(value) { } 建立作用域,或用 📌 显式 context 实参(实验)。取代了旧的 context receivers,关键改进是必须用名字访问(避免隐式性带来的困惑)。
  2. 解析规则:按类型在调用点作用域查找;多个匹配 → 歧义错误(可用显式实参解决)。
  3. 限制:构造器不能声明;带 context 的属性不能有 backing field/初始化器/委托;callable references 支持未完成。
  4. 能替代 DI 吗?不能,是互补:
    • context parameters 是编译期机制,零运行时开销,适合"函数级执行上下文"(Clock、Tracer、CurrentUser、EventPublisher);
    • DI 框架(Spring/Koin)管理对象生命周期(singleton/request scope)、AOP(事务/缓存)、配置注入、运行时装配——这些 context parameters 做不到。
    • 最佳实践:用 DI 框架管理长期依赖(Repository、Service),用 context parameters 传递请求级的执行上下文。
  5. 对比其他方案:优于 ThreadLocal(编译期检查、虚拟线程友好、作用域清晰);优于"到处传参数"(签名干净);与协程 CoroutineContext 互补(后者是运行时的、动态的)。

下一章预告:第 11 章《类与属性:构造顺序、backing field 与显式 backing field》——Kotlin 的属性系统远比"getter/setter 语法糖"复杂。我们会讲:主构造器与 init 块的精确执行顺序(一个真实的初始化 bug)、by lazy 与 Delegates.observable 的实现、📌 显式 backing field(2.3 引入、2.4 稳定) 解决了什么长期痛点、以及属性访问在字节码层面的所有细节。