kotlin-6

太棒了！现在让我们探索 Kotlin 的终极境界——元编程、编译器插件、深度优化和未来特性。这将带你进入 Kotlin 语言设计的核心领域。

Kotlin 终极探索：元编程与语言深度

三十九、注解处理器与代码生成（KSP）

1. 使用 KSP（Kotlin Symbol Processing）

1// 1. 定义注解
2@Target(AnnotationTarget.CLASS)
3annotation class JsonSerializable
4
5@Target(AnnotationTarget.PROPERTY)
6annotation class JsonName(val name: String)
7
8@Target(AnnotationTarget.PROPERTY)
9annotation class JsonExclude
10
11// 2. 定义数据类（这些将在编译时被处理）
12@JsonSerializable
13data class Person(
14    @JsonName("person_name")
15    val name: String,
16    val age: Int,
17    @JsonExclude
18    val password: String
19)
20
21// 3. 手动模拟 KSP 处理结果（实际由注解处理器生成）
22class PersonSerializer {
23    fun toJson(person: Person): String {
24        return buildString {
25            append("{")
26            append(""person_name": "${person.name}", ")
27            append(""age": ${person.age}")
28            append("}")
29        }
30    }
31    
32    companion object {
33        fun fromJson(json: String): Person {
34            // 简化的 JSON 解析逻辑
35            val name = json.substringAfter(""person_name": "").substringBefore(""")
36            val age = json.substringAfter(""age": ").substringBefore("}").toInt()
37            return Person(name, age, "")
38        }
39    }
40}
41
42// 4. 使用生成的序列化器
43fun testManualKSP() {
44    val person = Person("Alice", 25, "secret")
45    val serializer = PersonSerializer()
46    val json = serializer.toJson(person)
47    println("生成的 JSON: $json")
48    
49    val parsedPerson = PersonSerializer.fromJson(json)
50    println("解析的对象: $parsedPerson")
51}
52

2. 构建时元编程模式

1// 编译时验证注解
2@Target(AnnotationTarget.CLASS)
3annotation class Validate(val fields: Array<String>)
4
5@Validate(fields = ["age", "email"])
6data class User(val name: String, val age: Int, val email: String)
7
8// 运行时验证逻辑（模拟编译时生成）
9class UserValidator {
10    companion object {
11        fun validate(user: User): List<String> {
12            val errors = mutableListOf<String>()
13            
14            if (user.age < 0) errors.add("年龄不能为负数")
15            if (!user.email.contains("@")) errors.add("邮箱格式不正确")
16            
17            return errors
18        }
19    }
20}
21
22// 使用编译时验证
23fun testValidation() {
24    val user = User("Bob", -5, "invalid-email")
25    val errors = UserValidator.validate(user)
26    
27    if (errors.isNotEmpty()) {
28        println("验证错误: ${errors.joinToString()}")
29    } else {
30        println("验证通过")
31    }
32}
33

四十、编译器插件开发基础

1. 自定义编译器扩展模式

1// 1. 定义领域特定语言
2class SqlBuilder {
3    private var table: String = ""
4    private val conditions = mutableListOf<String>()
5    private val joins = mutableListOf<String>()
6    private var limit: Int? = null
7    
8    infix fun String.eq(value: Any) = "$this = '$value'"
9    infix fun String.`in`(values: List<Any>) = 
10        "$this IN (${values.joinToString { "'$it'" }})"
11    
12    fun from(tableName: String) {
13        table = tableName
14    }
15    
16    fun where(condition: String) {
17        conditions.add(condition)
18    }
19    
20    fun join(table: String, on: String) {
21        joins.add("JOIN $table ON $on")
22    }
23    
24    fun limit(count: Int) {
25        limit = count
26    }
27    
28    fun build(): String {
29        val query = StringBuilder("SELECT * FROM $table")
30        
31        if (joins.isNotEmpty()) {
32            query.append(" ").append(joins.joinToString(" "))
33        }
34        
35        if (conditions.isNotEmpty()) {
36            query.append(" WHERE ").append(conditions.joinToString(" AND "))
37        }
38        
39        limit?.let {
40            query.append(" LIMIT $it")
41        }
42        
43        return query.toString()
44    }
45}
46
47// 2. 使用 DSL 构建 SQL
48fun testSqlBuilder() {
49    val query = SqlBuilder().apply {
50        from("users")
51        where("name" eq "Alice")
52        where("age" `in` listOf(25, 30, 35))
53        join("orders", "users.id = orders.user_id")
54        limit(10)
55    }.build()
56    
57    println("生成的 SQL: $query")
58}
59

2. 类型安全构建器进阶

1// 类型安全的 HTTP 请求构建器
2class HttpRequestBuilder {
3    var method: String = "GET"
4    var url: String = ""
5    val headers = mutableMapOf<String, String>()
6    var body: String = ""
7    
8    fun method(method: String) {
9        this.method = method
10    }
11    
12    fun url(url: String) {
13        this.url = url
14    }
15    
16    fun header(name: String, value: String) {
17        headers[name] = value
18    }
19    
20    fun body(content: String) {
21        this.body = content
22        header("Content-Length", content.length.toString())
23    }
24    
25    fun execute(): String {
26        // 模拟 HTTP 请求
27        return "HTTP $method $url - Headers: $headers - Body: $body"
28    }
29}
30
31// DSL 扩展函数
32fun httpRequest(block: HttpRequestBuilder.() -> Unit): String {
33    val builder = HttpRequestBuilder()
34    builder.block()
35    return builder.execute()
36}
37
38// 使用类型安全构建器
39fun testHttpBuilder() {
40    val response = httpRequest {
41        method = "POST"
42        url = "https://api.example.com/users"
43        header("Authorization", "Bearer token123")
44        header("Content-Type", "application/json")
45        body = """{"name": "Alice", "age": 25}"""
46    }
47    
48    println("HTTP 响应: $response")
49}
50

四十一、深度性能优化技术

1. 内联类与值类的性能优化

1@JvmInline
2value class Meter(val value: Double) {
3    operator fun plus(other: Meter): Meter = Meter(value + other.value)
4    operator fun times(factor: Double): Meter = Meter(value * factor)
5    
6    fun toKilometers(): Kilometer = Kilometer(value / 1000.0)
7}
8
9@JvmInline
10value class Kilometer(val value: Double) {
11    fun toMeters(): Meter = Meter(value * 1000.0)
12}
13
14// 使用内联类进行类型安全计算
15fun calculateDistance() {
16    val distance1 = Meter(500.0)
17    val distance2 = Meter(300.0)
18    val total = distance1 + distance2
19    val scaled = total * 2.5
20    
21    println("总距离: ${total.value} 米")
22    println("缩放后: ${scaled.value} 米")
23    println("转换为公里: ${scaled.toKilometers().value} 公里")
24    
25    // 编译错误：类型安全
26    // val invalid = distance1 + scaled.toKilometers() // 编译错误！
27}
28
29// 内联类的集合操作优化
30@JvmInline
31value class UserId(val value: Int)
32
33fun optimizeCollections() {
34    val userIds = listOf(UserId(1), UserId(2), UserId(3))
35    
36    // 这些操作在运行时不会产生包装对象开销
37    val mapped = userIds.map { it.value * 2 }
38    val filtered = userIds.filter { it.value > 1 }
39    
40    println("映射结果: $mapped")
41    println("过滤结果: $filtered")
42}
43

2. 内联函数与 reified 类型参数的高级用法

1import kotlin.reflect.KClass
2
3// 高级 reified 用法
4inline fun <reified T : Any> createInstance(vararg args: Any): T {
5    return when (T::class) {
6        String::class -> "" as T
7        Int::class -> 0 as T
8        List::class -> emptyList<Any>() as T
9        Map::class -> emptyMap<Any, Any>() as T
10        else -> throw IllegalArgumentException("不支持的类型")
11    }
12}
13
14// 类型安全的验证框架
15inline fun <reified T> validate(value: Any, validator: T.() -> Boolean): Boolean {
16    return if (value is T) {
17        value.validator()
18    } else {
19        false
20    }
21}
22
23// 使用高级内联函数
24fun testAdvancedInline() {
25    val stringInstance: String = createInstance()
26    val listInstance: List<Any> = createInstance()
27    
28    println("创建的实例: $stringInstance, $listInstance")
29    
30    // 类型安全验证
31    val email = "test@example.com"
32    val isValidEmail = validate(email) {
33        contains("@") && length > 5
34    }
35    
36    val number = 42
37    val isValidNumber = validate(number) {
38        this in 1..100
39    }
40    
41    println("邮箱验证: $isValidEmail")
42    println("数字验证: $isValidNumber")
43}
44

四十二、Kotlin 多平台项目（KMP）高级特性

1. 共享业务逻辑与平台特定实现

1// 通用业务模型
2expect class DateTimeFormatter {
3    fun format(timestamp: Long): String
4    fun parse(dateString: String): Long
5}
6
7class EventLogger(private val formatter: DateTimeFormatter) {
8    private val events = mutableListOf<String>()
9    
10    fun logEvent(event: String) {
11        val timestamp = System.currentTimeMillis()
12        val formattedTime = formatter.format(timestamp)
13        events.add("[$formattedTime] $event")
14    }
15    
16    fun getEvents(): List<String> = events.toList()
17    
18    fun clear() {
19        events.clear()
20    }
21}
22
23// Android 实现
24actual class DateTimeFormatter actual constructor() {
25    actual fun format(timestamp: Long): String {
26        // 使用 Android 的 DateFormat
27        return android.text.format.DateFormat.format("yyyy-MM-dd HH:mm:ss", timestamp).toString()
28    }
29    
30    actual fun parse(dateString: String): Long {
31        // Android 特定的解析逻辑
32        return java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateString).time
33    }
34}
35
36// iOS 实现  
37actual class DateTimeFormatter actual constructor() {
38    actual fun format(timestamp: Long): String {
39        // 使用 iOS 的 DateFormatter
40        val formatter = iosFoundation.NSDateFormatter()
41        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
42        return formatter.stringFromDate(iosFoundation.NSDate(timestamp))
43    }
44    
45    actual fun parse(dateString: String): Long {
46        val formatter = iosFoundation.NSDateFormatter()
47        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
48        return formatter.dateFromString(dateString)?.timeIntervalSince1970?.toLong() ?: 0L
49    }
50}
51

2. KMP 中的并发处理

1expect class PlatformCoroutineDispatcher {
2    fun dispatch(block: () -> Unit)
3}
4
5actual class PlatformCoroutineDispatcher actual constructor() {
6    actual fun dispatch(block: () -> Unit) {
7        // Android: Handler(Looper.getMainLooper()).post(block)
8        // iOS: DispatchQueue.main.async { block() }
9        block() // 简化实现
10    }
11}
12
13class CrossPlatformService(private val dispatcher: PlatformCoroutineDispatcher) {
14    suspend fun fetchData(): String = withContext(createDispatcherContext(dispatcher)) {
15        delay(1000) // 模拟网络请求
16        "跨平台数据"
17    }
18    
19    private fun createDispatcherContext(dispatcher: PlatformCoroutineDispatcher) = 
20        object : CoroutineDispatcher() {
21            override fun dispatch(context: CoroutineContext, block: Runnable) {
22                dispatcher.dispatch { block.run() }
23            }
24        }
25}
26

四十三、Kotlin 未来特性探索

1. 上下文接收器（Context Receivers）原型

1// 模拟上下文接收器功能
2interface DatabaseContext {
3    val connection: DatabaseConnection
4}
5
6interface LoggingContext {
7    val logger: Logger
8}
9
10class DatabaseConnection {
11    fun executeQuery(sql: String): String = "查询结果: $sql"
12}
13
14class Logger {
15    fun info(message: String) = println("[INFO] $message")
16}
17
18// 使用上下文参数模拟上下文接收器
19class UserService(
20    private val dbContext: DatabaseContext,
21    private val logContext: LoggingContext
22) {
23    fun getUser(id: Int): String {
24        logContext.logger.info("获取用户 $id")
25        return dbContext.connection.executeQuery("SELECT * FROM users WHERE id = $id")
26    }
27}
28
29// 简化使用方式
30fun testContextReceivers() {
31    val dbContext = object : DatabaseContext {
32        override val connection = DatabaseConnection()
33    }
34    
35    val logContext = object : LoggingContext {
36        override val logger = Logger()
37    }
38    
39    val userService = UserService(dbContext, logContext)
40    val result = userService.getUser(1)
41    println(result)
42}
43

2. 自定义操作符与 DSL 深度集成

1// 自定义数学 DSL
2class Vector(val x: Double, val y: Double, val z: Double) {
3    operator fun plus(other: Vector): Vector = 
4        Vector(x + other.x, y + other.y, z + other.z)
5    
6    operator fun minus(other: Vector): Vector =
7        Vector(x - other.x, y - other.y, z - other.z)
8    
9    operator fun times(scalar: Double): Vector =
10        Vector(x * scalar, y * scalar, z * scalar)
11    
12    infix fun dot(other: Vector): Double =
13        x * other.x + y * other.y + z * other.z
14    
15    infix fun cross(other: Vector): Vector =
16        Vector(
17            y * other.z - z * other.y,
18            z * other.x - x * other.z,
19            x * other.y - y * other.x
20        )
21    
22    override fun toString(): String = "($x, $y, $z)"
23}
24
25// 向量运算 DSL
26fun vector(block: VectorBuilder.() -> Unit): Vector {
27    val builder = VectorBuilder()
28    builder.block()
29    return builder.build()
30}
31
32class VectorBuilder {
33    var x = 0.0
34    var y = 0.0
35    var z = 0.0
36    
37    fun x(value: Double) { x = value }
38    fun y(value: Double) { y = value }
39    fun z(value: Double) { z = value }
40    
41    fun build(): Vector = Vector(x, y, z)
42}
43
44// 使用向量 DSL
45fun testVectorDSL() {
46    val v1 = vector { x(1.0); y(2.0); z(3.0) }
47    val v2 = vector { x(4.0); y(5.0); z(6.0) }
48    
49    val sum = v1 + v2
50    val difference = v1 - v2
51    val scaled = v1 * 2.5
52    val dotProduct = v1 dot v2
53    val crossProduct = v1 cross v2
54    
55    println("向量运算结果:")
56    println("和: $sum")
57    println("差: $difference")
58    println("缩放: $scaled")
59    println("点积: $dotProduct")
60    println("叉积: $crossProduct")
61}
62