跳至正文

🎨 创建 DSL

📖 什么是 DSL？​

**DSL(Domain-Specific Language，领域特定语言)**是为特定领域量身定制的语言。使用 Kotlin 可以创建易读且直观的 API！

💡 基本概念​

Lambda 和接收者​

// 普通 lambda
fun buildString1(action: () -> String): String {
    return action()
}

// 带接收者的 lambda
fun buildString2(action: StringBuilder.() -> Unit): String {
    val builder = StringBuilder()
    builder.action()
    return builder.toString()
}

fun main() {
    val result = buildString2 {
        append("Hello ")  // this.append("Hello ")
        append("World!")
    }
    println(result)  // Hello World!
}

apply 和 with​

class Person {
    var name: String = ""
    var age: Int = 0
}

fun main() {
    // apply - 返回对象
    val person1 = Person().apply {
        name = "洪吉童"
        age = 25
    }

    // with - 返回结果
    val greeting = with(person1) {
        "您好，${name}！（${age}岁）"
    }

    println(greeting)
}

🎯 HTML DSL​

简单的 HTML 构建器​

class HtmlBuilder {
    private val content = StringBuilder()

    fun h1(text: String) {
        content.append("<h1>$text</h1>\n")
    }

    fun p(text: String) {
        content.append("<p>$text</p>\n")
    }

    fun div(block: HtmlBuilder.() -> Unit) {
        content.append("<div>\n")
        block()
        content.append("</div>\n")
    }

    override fun toString() = content.toString()
}

fun html(block: HtmlBuilder.() -> Unit): String {
    val builder = HtmlBuilder()
    builder.block()
    return builder.toString()
}

fun main() {
    val page = html {
        h1("Welcome!")
        p("This is a paragraph.")
        div {
            h1("Section")
            p("Content here.")
        }
    }

    println(page)
}

添加属性​

class Tag(val name: String) {
    private val attributes = mutableMapOf<String, String>()
    private val children = mutableListOf<Tag>()
    var text: String = ""

    fun attribute(key: String, value: String) {
        attributes[key] = value
    }

    operator fun String.unaryPlus() {
        text = this
    }

    override fun toString(): String {
        val attrs = attributes.entries.joinToString(" ") { "${it.key}=\"${it.value}\"" }
        val attrsString = if (attrs.isNotEmpty()) " $attrs" else ""

        return if (children.isEmpty() && text.isEmpty()) {
            "<$name$attrsString />"
        } else {
            val childrenString = children.joinToString("\n") { it.toString() }
            val content = if (text.isNotEmpty()) text else childrenString
            "<$name$attrsString>$content</$name>"
        }
    }
}

fun tag(name: String, block: Tag.() -> Unit): Tag {
    val tag = Tag(name)
    tag.block()
    return tag
}

fun main() {
    val div = tag("div") {
        attribute("class", "container")
        +"Hello World"
    }

    println(div)
    // <div class="container">Hello World</div>
}

🔧 SQL DSL​

查询构建器​

class Query {
    private var table: String = ""
    private val columns = mutableListOf<String>()
    private var whereClause: String = ""

    fun from(table: String) {
        this.table = table
    }

    fun select(vararg columns: String) {
        this.columns.addAll(columns)
    }

    fun where(condition: String) {
        whereClause = condition
    }

    fun build(): String {
        val cols = if (columns.isEmpty()) "*" else columns.joinToString(", ")
        var sql = "SELECT $cols FROM $table"
        if (whereClause.isNotEmpty()) {
            sql += " WHERE $whereClause"
        }
        return sql
    }
}

fun query(block: Query.() -> Unit): String {
    val query = Query()
    query.block()
    return query.build()
}

fun main() {
    val sql = query {
        select("id", "name", "email")
        from("users")
        where("age > 20")
    }

    println(sql)
    // SELECT id, name, email FROM users WHERE age > 20
}

🎨 配置 DSL​

应用配置​

class AppConfig {
    var host: String = "localhost"
    var port: Int = 8080
    var debug: Boolean = false

    private val routes = mutableListOf<Route>()

    fun route(path: String, block: Route.() -> Unit) {
        val route = Route(path)
        route.block()
        routes.add(route)
    }

    fun showConfig() {
        println("=== Config ===")
        println("Host: $host")
        println("Port: $port")
        println("Debug: $debug")
        println("\n=== Routes ===")
        routes.forEach { println(it) }
    }
}

class Route(val path: String) {
    var method: String = "GET"
    var handler: String = ""

    override fun toString() = "$method $path -> $handler"
}

fun configure(block: AppConfig.() -> Unit): AppConfig {
    val config = AppConfig()
    config.block()
    return config
}

fun main() {
    val config = configure {
        host = "example.com"
        port = 3000
        debug = true

        route("/api/users") {
            method = "GET"
            handler = "listUsers"
        }

        route("/api/users") {
            method = "POST"
            handler = "createUser"
        }
    }

    config.showConfig()
}

🎯 测试 DSL​

简单的测试框架​

class TestSuite(val name: String) {
    private val tests = mutableListOf<Test>()

    fun test(name: String, block: TestContext.() -> Unit) {
        tests.add(Test(name, block))
    }

    fun run() {
        println("=== $name ===\n")
        var passed = 0
        var failed = 0

        for (test in tests) {
            val context = TestContext()
            try {
                test.block(context)
                println("✓ ${test.name}")
                passed++
            } catch (e: AssertionError) {
                println("✗ ${test.name}: ${e.message}")
                failed++
            }
        }

        println("\n结果：$passed 通过，$failed 失败")
    }
}

class Test(val name: String, val block: TestContext.() -> Unit)

class TestContext {
    infix fun <T> T.shouldBe(expected: T) {
        if (this != expected) {
            throw AssertionError("Expected $expected but was $this")
        }
    }
}

fun describe(name: String, block: TestSuite.() -> Unit) {
    val suite = TestSuite(name)
    suite.block()
    suite.run()
}

fun main() {
    describe("Calculator") {
        test("addition") {
            val result = 2 + 3
            result shouldBe 5
        }

        test("subtraction") {
            val result = 5 - 2
            result shouldBe 3
        }

        test("multiplication") {
            val result = 3 * 4
            result shouldBe 12
        }
    }
}

🏗️ 构建器模式​

用户构建器​

class User private constructor(
    val name: String,
    val email: String?,
    val age: Int?,
    val address: String?
) {
    class Builder {
        private var name: String = ""
        private var email: String? = null
        private var age: Int? = null
        private var address: String? = null

        fun name(name: String) = apply { this.name = name }
        fun email(email: String) = apply { this.email = email }
        fun age(age: Int) = apply { this.age = age }
        fun address(address: String) = apply { this.address = address }

        fun build(): User {
            require(name.isNotBlank()) { "Name is required" }
            return User(name, email, age, address)
        }
    }

    override fun toString() = "User(name=$name, email=$email, age=$age, address=$address)"
}

fun user(block: User.Builder.() -> Unit): User {
    return User.Builder().apply(block).build()
}

fun main() {
    val user = user {
        name("洪吉童")
        email("hong@example.com")
        age(25)
        address("首尔")
    }

    println(user)
}

🤔 常见问题​

Q1. 何时使用 DSL？​

A: 让重复性任务变得简洁！

// ❌ 冗长的代码
val config = Config()
config.setHost("localhost")
config.setPort(8080)
config.addRoute("/api", "GET", "handler")

// ✅ DSL
val config = configure {
    host = "localhost"
    port = 8080
    route("/api") {
        method = "GET"
        handler = "handler"
    }
}

Q2. @DslMarker 是什么？​

A: 限制嵌套 DSL！

@DslMarker
annotation class HtmlDsl

@HtmlDsl
class HtmlTag {
    fun div(block: HtmlTag.() -> Unit) { }
}

fun html(block: HtmlTag.() -> Unit) {
    val tag = HtmlTag()
    tag.block()
}

Q3. 性能如何？​

A: 与普通代码几乎相同！

// 编译后生成几乎相同的字节码
val result1 = buildString {
    append("Hello")
}

val builder = StringBuilder()
builder.append("Hello")
val result2 = builder.toString()

🎬 结语​

使用 DSL 创建优雅的 API！

核心要点：
✅ 利用接收者 lambda
✅ 使用 apply、with 实现构建器模式
✅ 直观的语法
✅ 保持类型安全
✅ 领域特定语言

恭喜！您已经完成了 Practical 系列！🎉

下一步：在协程中学习异步编程！