Kotlin中传递多Lambda函数处理成功/失败场景的最优方案

嘿，作为Kotlin新手能关注到代码可读性这点真的很棒！你想要的那种更清晰的onSuccess/onFailure回调写法完全可以实现，下面给你几种实用的方案，从简单到进阶都有：

方案1：直接用命名参数（零成本改造） #

这是最简单的方式，不用修改你原来的getDeviceStatus函数，调用时明确指定参数名就能让代码瞬间清晰：

DeviceService.getDeviceStatus(
    onSuccess = { device -> println("设备信息：$device") },
    onFailure = { errorMsg -> println("出错了：$errorMsg") }
)

Kotlin的命名参数特性就是为了解决这种“Lambda用途不明确”的问题，一眼就能看出每个Lambda对应的回调逻辑，完全不用猜参数顺序。

方案2：带接收者的Lambda（实现你想要的块写法） #

如果你想写成类似{ onSuccess{...} onFailure{...} }这种直观的块结构，可以重构原函数，利用Kotlin的带接收者的Lambda特性：

首先定义一个回调配置类：

class DeviceStatusCallback {
    var onSuccess: ((Device) -> Unit)? = null
    var onFailure: ((String) -> Unit)? = null
}

然后重构getDeviceStatus函数，让它接收一个配置Lambda：

fun getDeviceStatus(config: DeviceStatusCallback.() -> Unit) {
    val callback = DeviceStatusCallback().apply(config)
    FuelClient.get(DEVICE_URL,
        success = { responseString ->
            val adapter = MoshiUtil.moshi.adapter(Device::class.java)
            val device = adapter.fromJson(responseString)!!
            callback.onSuccess?.invoke(device)
        },
        failure = {
            callback.onFailure?.invoke(it.message!!)
        }
    )
}

现在调用的时候就可以写成你设想的样子了：

DeviceService.getDeviceStatus {
    onSuccess { device -> println("设备信息：$device") }
    onFailure { errorMsg -> println("出错了：$errorMsg") }
}

这种写法把回调逻辑封装在一个块里，每个回调都有明确的名称，可读性拉满。

方案3：链式调用风格（流畅的API设计） #

如果你偏好.onSuccess{...}.onFailure{...}这种链式写法，可以让函数返回一个可链式调用的对象：

先定义链式回调类：

class DeviceStatusChain {
    private var successHandler: ((Device) -> Unit)? = null
    private var failureHandler: ((String) -> Unit)? = null

    fun onSuccess(block: (Device) -> Unit): DeviceStatusChain {
        successHandler = block
        return this
    }

    fun onFailure(block: (String) -> Unit): DeviceStatusChain {
        failureHandler = block
        return this
    }

    // 触发请求的方法
    fun execute() {
        FuelClient.get(DEVICE_URL,
            success = { responseString ->
                val adapter = MoshiUtil.moshi.adapter(Device::class.java)
                val device = adapter.fromJson(responseString)!!
                successHandler?.invoke(device)
            },
            failure = {
                failureHandler?.invoke(it.message!!)
            }
        )
    }
}

然后修改getDeviceStatus函数返回这个链式对象：

fun getDeviceStatus(): DeviceStatusChain {
    return DeviceStatusChain()
}

现在调用就是你想要的流畅链式写法：

DeviceService.getDeviceStatus()
    .onSuccess { device -> println("设备信息：$device") }
    .onFailure { errorMsg -> println("出错了：$errorMsg") }
    .execute()

这种写法非常符合现代API的设计风格，逻辑流程一目了然，唯一需要多调用一个execute()来触发请求。

方案4：Kotlin协程+Result（推荐的进阶方案） #

如果你的项目已经引入了Kotlin协程，这是处理异步请求最优雅的方式，完全摆脱回调嵌套，代码更像同步写法：

首先把原函数改成挂起函数，返回Result<Device>类型：

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlin.Result

suspend fun getDeviceStatus(): Result<Device> = withContext(Dispatchers.IO) {
    return@withContext try {
        // 这里假设Fuel有同步请求方法，或者使用Fuel的协程扩展库
        val responseString = FuelClient.getSync(DEVICE_URL)
        val adapter = MoshiUtil.moshi.adapter(Device::class.java)
        val device = adapter.fromJson(responseString)!!
        Result.success(device)
    } catch (e: Exception) {
        Result.failure(e)
    }
}

然后在协程作用域内调用（比如ViewModel的viewModelScope、Activity的lifecycleScope或者runBlocking）：

runBlocking {
    DeviceService.getDeviceStatus().fold(
        onSuccess = { device -> println("设备信息：$device") },
        onFailure = { error -> println("出错了：${error.message}") }
    )
}

协程让异步代码同步化，Result类型统一处理成功和失败，fold方法可以清晰地分支处理两种情况，代码简洁易维护，这也是Kotlin官方推荐的异步处理方式。

内容的提问来源于stack exchange，提问作者7200rpm