Kotlin泛型+策略模式实现多支付方式时遇类型不匹配问题

问题背景 #

我要实现一个支持多种支付方式的后端系统，按支付类型处理业务，采用策略模式实现，但初始化服务时出现类型不匹配错误，推测是对Kotlin泛型的理解有偏差。

初始化代码报错 #

val gateways =
        listOf(
            CreditGateway(),
            PayPalGateway()
        )
val api = PaymentAPI(gateways) <-- error: Type mismatch 
api.authorizeFunds(PayPalModel(...))

Required:
List<IPaymentService<IPaymentModel>>
Found:
List<IPaymentService<{CreditModel & PayPalModel}>>

完整代码实现 #

interface IPaymentModel

class CreditModel : IPaymentModel
class PayPalModel : IPaymentModel

interface IPaymentService<in T> where T: IPaymentModel {
    suspend fun authorizeFunds(model: T)
    suspend fun appliesTo(type: IPaymentModel): Boolean
}

class CreditGateway : IPaymentService<CreditModel> {
    override suspend fun authorizeFunds(model: CreditModel) {
      /// implementation
    }
    override suspend fun appliesTo(type: IPaymentModel): Boolean {
        return type is CreditModel
    }
}

class PayPalGateway : IPaymentService<PayPalModel> {
    override suspend fun authorizeFunds(model: PayPalModel) {
      /// implementation
    }
    override suspend fun appliesTo(type: IPaymentModel): Boolean {
        return type is PayPalModel
    }
}

interface IPaymentStrategy<T: IPaymentService<IPaymentModel>> {
    suspend fun <T: IPaymentModel> authorizeFunds(model: T)
}

class PaymentAPI(
    private val paymentServices: List<IPaymentService<IPaymentModel>>
): IPaymentStrategy<IPaymentModel> {

    override suspend fun <T : IPaymentModel> authorizeFunds(model: T) {
        findService(model)?.authorizeFunds(model)
    }
    
    private fun <T : IPaymentModel> findService(model: T) ????
}

问题分析 #

1. 泛型逆变导致类型不匹配：IPaymentService<in T> 使用逆变泛型（in 关键字），表示接口消费类型 T。根据Kotlin泛型规则，逆变方向与类继承方向相反——IPaymentService<CreditModel> 无法直接向上转型为 IPaymentService<IPaymentModel>，这是初始化报错的核心原因。
2. IPaymentStrategy 泛型定义混乱：接口与方法重复定义了泛型参数 T，两个 T 是独立变量，导致泛型约束完全失效。
3. 类型安全隐患：即使强行绕过类型检查，直接调用 authorizeFunds(model) 可能出现运行时类型错误（比如将 PayPalModel 传给 CreditGateway）。

解决方案 #

步骤1：修复IPaymentStrategy的泛型定义 #

移除接口上冗余的泛型参数，让方法泛型直接约束支付模型：

interface IPaymentStrategy {
    suspend fun <T : IPaymentModel> authorizeFunds(model: T)
}

步骤2：调整PaymentAPI的参数与实现 #

使用星号投影（IPaymentService<*>）接受任意支付服务，同时通过类型转换保证调用安全：

class PaymentAPI(
    private val paymentServices: List<IPaymentService<*>>
) : IPaymentStrategy {

    override suspend fun <T : IPaymentModel> authorizeFunds(model: T) {
        @Suppress("UNCHECKED_CAST")
        val service = findService(model) as? IPaymentService<T>
        service?.authorizeFunds(model)
    }
    
    private fun findService(model: IPaymentModel): IPaymentService<*>? {
        return paymentServices.firstOrNull { it.appliesTo(model) }
    }
}

步骤3：正确初始化支付服务列表 #

显式指定列表类型为 List<IPaymentService<*>>，避免Kotlin自动推断出错误的交集类型：

val gateways = listOf<IPaymentService<*>>(
    CreditGateway(),
    PayPalGateway()
)
val api = PaymentAPI(gateways)
api.authorizeFunds(PayPalModel())

可选优化：增强类型安全 #

如果想完全避免类型转换，可以用密封类限制支付模型范围，同时简化接口设计：

// 密封类限制支付模型的子类范围
sealed class IPaymentModel
class CreditModel : IPaymentModel()
class PayPalModel : IPaymentModel()

interface IPaymentService {
    suspend fun authorizeFunds(model: IPaymentModel)
    fun appliesTo(model: IPaymentModel): Boolean
}

class CreditGateway : IPaymentService {
    override suspend fun authorizeFunds(model: IPaymentModel) {
        if (model is CreditModel) {
            // 处理信用卡支付逻辑
        }
    }

    override fun appliesTo(model: IPaymentModel): Boolean {
        return model is CreditModel
    }
}

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