如何实现 LogUtils.printCostTime().next("生成密钥") { val key = SecureEncryptor.generateAESKey() println(key) key }.next("加密文本") { }.next("解密文本") { } 能接收上一个 next的值

要实现 `LogUtils.printCostTime().next().next().next()` 这样的链式调用，并且每个 `next` 方法都能接收上一个 `next` 的返回值，你可以将 `LogUtils` 类的 `next` 方法定义为一个带有泛型参数的函数类型，并在每个 `next` 方法中使用 `invoke` 函数来执行传入的代码块。以下是一个示例的 Kotlin 代码：

import java.util.concurrent.TimeUnit

// 表格打印方法耗时
fun logMethodExecutionTime(tag: String, methodName: String, executionTime: Long) {
    val threadName = Thread.currentThread().name
    val formattedTime = String.format("%02d:%02d:%02d.%03d",
        TimeUnit.MILLISECONDS.toHours(executionTime),
        TimeUnit.MILLISECONDS.toMinutes(executionTime) % 60,
        TimeUnit.MILLISECONDS.toSeconds(executionTime) % 60,
        executionTime % 1000)

    val headerFormat = "| %-10s | %-20s | %-12s |"
    val rowFormat = "| %-10s | %-20s | %-12s |"
    val separator = "+------------+----------------------+--------------+"

    val header = String.format(headerFormat, "Thread", "Method", "Execution Time")
    val row = String.format(rowFormat, threadName, methodName, formattedTime)

    println(separator)
    println(header)
    println(separator)
    println(row)
    println(separator)
}

// LogUtils 工具类
class LogUtils {
    companion object {
        private var startTime: Long = 0

        fun printCostTime(tag: String): LogUtils {
            startTime = System.currentTimeMillis()
            return this
        }

        operator fun <T> invoke(block: () -> T): T {
            val result = block()
            val endTime = System.currentTimeMillis()
            val executionTime = endTime - startTime
            logMethodExecutionTime("TAG", "Method", executionTime)
            return result
        }
    }

    infix fun <T> next(taskName: String, block: () -> T): LogUtils {
        invoke(block)
        return this
    }
}

// 使用示例
fun main() {
    LogUtils.printCostTime("TAG")
        .next("生成密钥") {
            val key = SecureEncryptor.generateAESKey()
            println(key)
            key
        }
        .next("加密文本") {
            // 在这里可以使用上一个 next 的返回值
        }
        .next("解密文本") {
            // 在这里可以使用上一个 next 的返回值
        }
}

在上面的代码中，我们将 `LogUtils` 类的 `next` 方法定义为一个带有泛型参数的函数类型，并使用 `invoke` 函数来执行传入的代码块。在每个 `next` 方法中，我们调用 `invoke` 函数来执行传入的代码块，并在其中记录方法的耗时。每个 `next` 方法都返回 `LogUtils` 对象，以支持链式调用。

在示例中，我们使用 `LogUtils.printCostTime("TAG")` 开始记录总耗时，然后使用 `.next("生成密钥") { ... }` 执行生成密钥的任务，并在其中打印密钥。接着，我们可以在后续的 `.next("加密文本") { ... }` 和 `.next("解密文本") { ... }` 任务中使用上一个任务的返回值。

请注意，以上代码只是一个示例，并没有包含完整的异常处理和线程安全性。在实际使用中，你可能需要根据你的需求进行适当的调整和扩展。