Kotlin DSL 基础：语法速览与核心特性

各位同学，欢迎来到第二章。上一章我们聊了 Gradle 和 Kotlin DSL 的整体面貌，今天咱们就扎进 Kotlin 这门语言本身，看看那些在 Gradle 脚本里天天打交道的语法特性。

说实话，我刚开始从 Groovy 切到 Kotlin DSL 时，心里是有点抵触的。Groovy 写起来多随意啊，括号都能省。但用了一段时间 Kotlin 后，真香——类型安全、IDE 补全、编译时检查，这些在大型项目里太重要了。今天要讲的这几个特性，是你在 Gradle 脚本里几乎每行都会用到的。

Kotlin 语法速览：够用就行

咱们不搞学院派那一套，直接看 Gradle 脚本里最常见的写法。

变量声明：val 和 var。我个人习惯，能用 val 绝不用 var。为什么？因为不可变意味着更少的意外。

val projectName = "MyApp"  // 只读，类似 final
var buildCount = 0          // 可变，尽量少用

类型推断：Kotlin 会自动推断类型，但你也可以显式声明。在 Gradle 脚本里，我建议关键地方显式写类型，方便后来人阅读。

val versionCode: Int = 1
val versionName: String = "1.0.0"

空安全：这是 Kotlin 最让我安心的特性。Groovy 里随便一个 ?. 就可能 NPE，Kotlin 在编译期就帮你堵住了。

var name: String? = null  // 可空类型
name?.length              // 安全调用，不会崩
name!!.length             // 强制非空，慎用！

Lambda 与闭包：Gradle 脚本的灵魂

Gradle 脚本说白了就是一堆 Lambda 的嵌套。你看 android { ... }、dependencies { ... }，本质上都是 Lambda 表达式。

Lambda 的基本写法：

// 完整写法
val sum: (Int, Int) -> Int = { a: Int, b: Int -> a + b }

// 简化写法（类型推断）
val sum = { a: Int, b: Int -> a + b }

// 如果 Lambda 是最后一个参数，可以提到括号外面
listOf(1, 2, 3).map { it * 2 }

在 Gradle 里，你几乎天天见到这种模式：

android {
    compileSdk = 34
    
    defaultConfig {
        applicationId = "com.example.app"
    }
}

你看，android { ... } 就是一个 Lambda，它接收一个 AndroidExtension 类型的接收者。这就是所谓的「带接收者的 Lambda」——你可以在 Lambda 内部直接调用接收者的方法，不用写 it.。

闭包与变量捕获：Lambda 可以访问外部作用域的变量，这就是闭包。在 Gradle 脚本里，你经常会在 subprojects { } 里引用根项目的变量。

val commonVersion = "1.0.0"

subprojects {
    // 这里可以访问 commonVersion
    dependencies {
        implementation("com.example:lib:$commonVersion")
    }
}

扩展函数：给 Gradle API 加点料

扩展函数是 Kotlin 最实用的特性之一。说白了，就是给一个已有的类添加新方法，不用继承，不用修改源码。

基本语法：

// 给 String 类添加一个扩展函数
fun String.isValidPackageName(): Boolean {
    return this.matches(Regex("^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)*$"))
}

// 使用
val pkg = "com.example.app"
println(pkg.isValidPackageName())  // true

在 Gradle 脚本里，扩展函数无处不在。比如 DependencyHandler 的 implementation() 方法，其实就是扩展函数。

// 实际上是这样定义的
fun DependencyHandler.implementation(dependencyNotation: Any): Dependency?

我自己写 Gradle 插件时，特别喜欢用扩展函数来封装重复逻辑。比如给 Project 加一个获取版本号的方法：

fun Project.getVersionCode(): Int {
    return (findProperty("versionCode") as? String)?.toIntOrNull() ?: 1
}

// 在 build.gradle.kts 里直接用
val code = getVersionCode()

委托属性：懒加载与观察者模式

委托属性是 Kotlin 的高级特性，但在 Gradle 脚本里用得不多。不过理解它，能帮你更好地理解某些 Gradle API 的设计。

基本概念：属性的 getter/setter 委托给另一个对象处理。

// 标准委托：lazy
val config: String by lazy {
    // 第一次访问时初始化，之后缓存
    loadConfigFromFile()
}

// 标准委托：observable
var name: String by Delegates.observable("default") { 
    prop, old, new ->
    println("$old -> $new")
}

在 Gradle 里，lazy 委托很常见。比如你定义了一个任务，它的配置可能依赖其他任务的结果：

val myTask by tasks.registering {
    // 这个 Lambda 只有在任务被执行时才会运行
    doLast {
        println("任务执行了")
    }
}

这里的 by tasks.registering 本质上就是一种委托——它把任务的创建和配置延迟到了真正需要的时候。

DSL 标记注解：@DslMarker

这个特性可能很多同学没听说过，但它在 Gradle 脚本里默默发挥着重要作用。

问题场景：当你在一个 Lambda 内部嵌套另一个 Lambda 时，两个 Lambda 的接收者类型可能不同。如果没有限制，你可能会不小心调用到外层接收者的方法，造成歧义。

// 假设有两个接收者
class Outer {
    fun foo() { println("outer") }
}

class Inner {
    fun bar() { println("inner") }
}

// 嵌套 Lambda
Outer().apply {
    foo()  // 没问题
    Inner().apply {
        bar()  // 没问题
        foo()  // 也能调用！但可能不是你想要的行为
    }
}

@DslMarker 的作用：限制内部 Lambda 不能访问外部接收者的隐式成员。Gradle 的很多 DSL 块都用了这个注解。

@DslMarker
annotation class MyDslMarker

@MyDslMarker
class Outer {
    fun foo() { println("outer") }
}

@MyDslMarker
class Inner {
    fun bar() { println("inner") }
}

// 现在内部 Lambda 不能调用外部的 foo()
Outer().apply {
    foo()
    Inner().apply {
        bar()
        // foo()  // 编译错误！被 @DslMarker 限制了
    }
}

在 Gradle 里，android { } 和 defaultConfig { } 之间就有这种限制。你不能在 defaultConfig 内部直接调用 compileSdk，因为那是 android 块的方法。

知识体系总览

下面这张图总结了本章的核心知识点和它们之间的关系：

这张图把今天的内容串起来了。你看，语法速览是基础，Lambda 和扩展函数是 Gradle 脚本的两大支柱，委托属性和 @DslMarker 则是进阶工具。实际写脚本时，这些特性往往是组合使用的。

小结

今天的内容不少，但都是干货。总结一下：

• 语法速览：val/var、类型推断、空安全——这三样你每天都会用
• Lambda 与闭包：Gradle 脚本的本质，带接收者的 Lambda 是 DSL 的核心
• 扩展函数：给 Gradle API 加糖，写插件时特别有用
• 委托属性：lazy 和 observable 最常用，理解原理即可
• @DslMarker：保证 DSL 的清晰和安全，写自定义 DSL 时别忘了加

嗯，这些概念光看可能有点抽象。下一章我们会实际动手写一个 Gradle 脚本，把这些特性都用上。到时候你会发现，原来它们就在你每天写的 build.gradle.kts 里。

---