Kotlin缺失Union类型支持下的多类型输入处理优化方案问询

问题背景 #

现有Service1通过方法重载支持两种输入类型（A和B），返回C类型结果。需要实现Service2，提供一个能接收Service1所有输入类型的方法，对结果做统一处理，避免重复逻辑。目前有两个方案但都不够理想，希望找到类似伪代码中基于泛型约束的简洁实现方式。

现有代码与方案 #

基础定义 #

data class A(...)
data class B(...)
class C

class Service1 {
    fun doSomething(input: A): C {}
    fun doSomething(input: B): C {}
}

方案1：泛型+类型判断 #

通过泛型统一方法签名，用when分支匹配输入类型。缺点是新增类型时需手动修改when块，维护成本高。

class Service2_v1(private val service: Service1) {
    fun <T> doThings(input: T) {
        val result = when(input) {
            is A -> service.doSomething(input)
            is B -> service.doSomething(input)
            else -> throw IllegalArgumentException()
        }
        // 处理result的逻辑
    }
}

方案2：重载方法+公共处理 #

通过重载doThings方法，将公共逻辑抽至handleResult。优点是类型安全，但新增类型时需新增重载方法，存在重复代码。

class Service2_v2(private val service: Service1) {
    fun doThings(input: A) = handleResult(service.doSomething(input))
    fun doThings(input: B) = handleResult(service.doSomething(input))

    private fun handleResult(result: C) {
        // 统一处理result的逻辑
    }
}

期望的伪代码（未实现） #

希望通过泛型约束直接限定输入类型为Service1.doSomething的参数类型，实现单一方法处理所有合法输入：

class Service2_notWorking(private val service: Service1) {
    fun <T : ArgumentTypeOf<Service1.doSomething>> doThings(input: T) {
        val result = service.doSomething(input)
        // 处理result的逻辑
    }
}

更优解决方案 #

方案3：内联具体化泛型（编译期类型检查） #

利用Kotlin的inline reified特性在编译期确定类型，既保持单一方法签名，又避免运行时类型转换的风险（编译期即可发现不支持的类型）：

class Service2_v3(private val service: Service1) {
    inline fun <reified T> doThings(input: T) {
        val result = when (T::class) {
            A::class -> service.doSomething(input as A)
            B::class -> service.doSomething(input as B)
            else -> error("不支持的输入类型: ${T::class.simpleName}")
        }
        handleResult(result)
    }

    private fun handleResult(result: C) {
        // 统一处理result的逻辑
    }
}

方案4：保留重载+简化公共逻辑（类型安全最优） #

如果优先保证类型安全（避免运行时异常），可以对方案2做小优化，用内联函数封装类型匹配逻辑，减少重复代码：

class Service2_v4(private val service: Service1) {
    fun doThings(input: A) = process(input)
    fun doThings(input: B) = process(input)

    private inline fun <T> process(input: T) {
        val result = when (input) {
            is A -> service.doSomething(input)
            is B -> service.doSomething(input)
            else -> throw IllegalArgumentException()
        }
        handleResult(result)
    }

    private fun handleResult(result: C) {
        // 统一处理result的逻辑
    }
}

方案5：抽象输入类型（需修改基础类） #

如果允许修改A、B和Service1，可以定义一个公共接口标记合法输入类型，彻底简化逻辑：

// 新增接口标记合法输入
interface ValidInput
data class A(...) : ValidInput
data class B(...) : ValidInput

// 修改Service1
class Service1 {
    fun doSomething(input: ValidInput): C = when(input) {
        is A -> // 处理A的逻辑
        is B -> // 处理B的逻辑
        else -> throw IllegalArgumentException()
    }
}

// Service2实现
class Service2_v5(private val service: Service1) {
    fun doThings(input: ValidInput) {
        val result = service.doSomething(input)
        handleResult(result)
    }

    private fun handleResult(result: C) {
        // 统一处理result的逻辑
    }
}

方案选择建议 #

• 若无法修改基础类且偏好单一方法签名：选择方案3，利用inline reified实现编译期类型检查。
• 若优先保证类型安全、避免运行时异常：选择方案4，在方案2基础上简化重复逻辑，兼顾简洁性与安全性。
• 若允许修改基础类：选择方案5，通过抽象接口实现最简洁的逻辑，扩展性最好。

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