Kotlin学习 11 -- 使用 DSL 构建专有的语法结构

本篇文章主要介绍以下几个知识点：

Kotlin DSL
内容参考自第一行代码第3版

SUMMER DAY (图片来源于网络)

DSL 的全称是领域特定语言（Domain Specific Language），通过它可以编写出一些看似脱离其原始语法结构的代码，从而构建出一种专有的语法结构。

举个栗子，平时在项目中添加依赖库的语法结构就是 Groovy 语言的提供的 DSL 功能：

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0"
}

在 Kotlin 中实现 DSL 的方式不固定，最常见的是通过高阶函数的方式来实现。（其他比如用 infix 函数构建出特有的语法结构）。

接下来借助 Kotlin 的 DSL来实现类似上面添加依赖库的语法结构，首先创建个 DSL.kt 文件，里面定义个 Dependency 类如下：

class Dependency {
    // 定义个 list 来保存所有依赖库
    val libraries = ArrayList<String>()

    // 定义向 list 中添加依赖库的方法
    fun implementation(lib: String) {
        libraries.add(lib)
    }
}

接下来定义一个 dependencies 高阶函数如下：

// 把函数类型参数定义到 Dependency 类中，调用它时先创建实例，通过实例调用函数类型参数
// 传入的 Lambda 表达式就能得到执行，最后把保存的依赖库集合返回
fun dependencies(block: Dependency.() -> Unit): List<String> {
    val dependency = Dependency()
    dependency.block()
    return dependency.libraries
}

经过这样的 DSL 设计后，就可以在项目中使用如下的语法结构了：

dependencies {
    // dependencies 接收一个函数类型参数 Lambda 表达式，此时表达式中有 Dependency 的上下文，
    // 从而可以直接调用 Dependency 类中方法
    implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0")
    implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0")
}

另外，还可以通过 dependencies 函数的返回值来获取所添加的依赖库：

fun main() {
    val libraries = dependencies {
        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0")
        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0")
    }
    for (lib in libraries) {
        println(lib)
    }
}
// 打印结果：
// org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0
// org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0

这种语法结构比直接调用 Dependency 对象的 implementation() 方法更加直观，当添加的依赖库越多，使用 DSL 写法的优势越明显。

再举个栗子，在 Kotlin 中借助 DSL 定义一种语法结构来动态生成表格所对应的 HTML 代码，其中 HTML 代码如下：

<!-- 一个两行三列的 html 表格 -->
<table>
    <tr>
        <td>apple</td>
        <td>grape</td>
        <td>orange</td>
    </tr>
    <tr>
        <td>pear</td>
        <td>banana</td>
        <td>orange</td>
    </tr>
</table>

若用字符串拼接的方式来实现显然十分繁琐，也难以阅读。而借助 DSL 构建的语法结构能够轻松实现生成上面的 HTML 代码。

首先定义个 Td 类如下：

// <td> 标签表示一个单元格
class Td {
    // 定义 content 字段来存储单元格的显示内容
    var content = ""

    // 定义返回一段<td>标签的 html 代码的方法
    fun html() = "\n\t\t<td>$content</td>"
}

接着再定义个 Tr 类如下：

// <tr> 标签表示表格的行，可包含多个 <td> 标签
class Tr {
    // 定义个集合来存储当前 Tr 所包含的 Td 对象
    private val children = ArrayList<Td>()

    // 定义向集合中添加 Td 对象的方法
    fun td(block: Td.() -> String) {
        val td = Td()
        td.content = td.block()
        children.add(td)
    }

    // 定义返回一段<tr>标签的 html 代码的方法
    fun html() = StringBuilder().apply {
        append("\n\t<tr>")
        for (childTag in children) {
            append(childTag.html())
        }
        append("\n\t</tr>")
    }.toString()
}

现在，就可以用如下语法来构建表格中的一行数据：

val tr = Tr()
tr.td { "apple" }
tr.td { "grape" }
tr.td { "orange" }

最后再定义个 Table 类如下：

// <table> 标签包含多个 <tr> 标签
class Table {
    private val children = ArrayList<Tr>()

    fun tr(block: Tr.() -> Unit) {
        val tr = Tr()
        tr.block()
        children.add(tr)
    }

    fun html() = StringBuilder().apply {
        append("<table>")
        for (childTag in children) {
            append(childTag.html())
        }
        append("\n</table>")
    }.toString()
}

这样，就可以用如下语法来构建一个表格了：

val table = Table()
table.tr { 
    td { "apple" }
    td { "grape" }
    td { "orange" }
}
table.tr { 
    td { "pear" }
    td { "banana" }
    td { "orange" }
}

当然，还可以进一步精简，定义个 table() 函数如下：

fun table(block: Table.() -> Unit): String {
    val table = Table()
    table.block()
    return table.html()
}

现在就可以用以下语法结构来动态生成一个表格对应的 HTML 代码了：

fun main() {
    val html = table {
        tr {
            td { "apple" }
            td { "grape" }
            td { "orange" }
        }
        tr {
            td { "pear" }
            td { "banana" }
            td { "orange" }
        }
    }
    println(html)
}

另外，在 DSL 中也可以用 Kotlin 的其他语法特性，比如循环来批量生成标签：

fun main() {
    val html = table {
        repeat(2) {
            tr {
                val fruits = listOf("apple", "grape", "orange")
                for (fruit in fruits) {
                    td { fruit }
                }
            }
        }
    }
}

小结：构建 DSL，只是通过对高阶函数的灵活运用，编写出一段看似不属于 Kotlin 语言的语法结构。这里只是提供了下 DSL 定制的思路。

本篇文章就介绍到这。