Kotlin装饰器模式适用哪些场景

Kotlin 装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许在不修改原始类代码的情况下，动态地为对象添加新的功能或行为。装饰器模式在 Kotlin 中非常实用，可以应用于以下场景：

1. 日志记录：在函数或类的方法执行前后，记录日志信息，以便于跟踪和调试。通过装饰器模式，可以为不同的方法或类添加不同的日志记录逻辑。

fun <T> log(message: String, block: T.() -> Unit): T {
    return object : T by block {
        override fun toString(): String {
            return message + super.toString()
        }
    }
}

fun main() {
    val result = log("Before") {
        println("Inside the function")
    }
    println(result)
}

1. 权限验证：在执行敏感操作之前，检查用户是否具有相应的权限。通过装饰器模式，可以为不同的方法添加不同的权限验证逻辑。

fun <T> authorize(permissions: Set<String>, block: T.() -> Unit): T {
    return object : T by block {
        override fun checkPermission(permission: String): Boolean {
            return permissions.contains(permission)
        }
    }
}

fun main() {
    val authorizedResult = authorize(setOf("READ")) {
        println("Inside the function")
    }
    authorizedResult.checkPermission("WRITE") // true
}

1. 缓存：在执行耗时操作之前，检查缓存中是否已经存在结果。如果存在，则直接返回缓存结果；否则，执行原始操作并将结果存入缓存。通过装饰器模式，可以为不同的方法添加不同的缓存逻辑。

fun <T> cache(block: T.() -> Unit): T {
    val cache = mutableMapOf<String, Any>()
    return object : T by block {
        override fun execute(): Any? {
            val key = this::class.toString()
            return cache.getOrPut(key) { super.execute() }
        }
    }
}

fun main() {
    val cachedResult = cache {
        println("Inside the function")
    }
    val result = cachedResult.execute() // Inside the function
}

1. 性能监控：在执行方法时，记录方法的执行时间，以便于分析性能瓶颈。通过装饰器模式，可以为不同的方法添加不同的性能监控逻辑。

fun <T> measurePerformance(block: T.() -> Unit): T {
    return object : T by block {
        override fun execute(): Any? {
            val startTime = System.currentTimeMillis()
            val result = super.execute()
            val endTime = System.currentTimeMillis()
            println("Execution time: ${endTime - startTime} ms")
            return result
        }
    }
}

fun main() {
    val performanceResult = measurePerformance {
        println("Inside the function")
    }
    performanceResult.execute() // Inside the function
}

这些场景仅仅是装饰器模式在 Kotlin 中的一些应用示例，实际上，只要需要在运行时为对象添加新的功能或行为，都可以考虑使用装饰器模式。