非反射实现：参数为泛型时如何调用Processor接口的process方法？

我们有一个泛型接口Processor<T>的大量实现类实例列表，需要获取任意类型的元素，通过过滤逻辑找到对应的处理器实例，如何在不使用反射的前提下调用其process方法并传入该元素？

原始代码示例 #

interface Processor<T> {
  fun process(element: T)
  // [更多方法...]
}

// 各类实现类
class StringProcessor : Processor<String> {
  override fun process(element: String) {}
}

class IntProcessor : Processor<Int> {
  override fun process(element: Int) {}
}
// 另有50+针对不同类型的实现类

// 调用逻辑
fun main() {
  val allProcessors = listOf(StringProcessor(), IntProcessor()) // 动态加载的实例列表

  val elementToProcess = "Test"
  val correctProcessor = allProcessors
    .first { /* 判断元素类型与处理器泛型类型匹配的逻辑 */ true }
  
  correctProcessor.process(elementToProcess) // <-- 此处无法直接编译通过，如何解决？
}

现有反射方案（不推荐） #

目前我们找到一种可行但不够优雅的反射实现：

fun main() {
  val allProcessors = listOf(StringProcessor(), IntProcessor()) // 动态加载的实例列表

  val elementToProcess = "Test"
  val correctProcessor = allProcessors
    .first { /* 判断元素类型与处理器泛型类型匹配的逻辑 */ true }
  
  // 反射调用，可行但存在性能隐患与类型不安全问题
  val method = correctProcessor::class.java.getMethod("process", Any::class.java)
  method.invoke(correctProcessor, elementToProcess)
}

以下是几种无需反射的类型安全实现方案：

方案1：为接口添加非泛型桥接方法 #

修改Processor接口，新增一个接收Any类型参数的桥接方法，内部通过类型转换调用泛型的process方法：

interface Processor<T> {
  fun process(element: T)
  
  // 新增非泛型桥接方法
  fun processElement(element: Any) {
    @Suppress("UNCHECKED_CAST")
    process(element as T)
  }
  
  // [更多方法...]
}

// 原有实现类无需修改，自动继承桥接方法
class StringProcessor : Processor<String> {
  override fun process(element: String) {}
}

class IntProcessor : Processor<Int> {
  override fun process(element: Int) {}
}

// 调用逻辑直接使用桥接方法
fun main() {
  val allProcessors = listOf(StringProcessor(), IntProcessor())
  val elementToProcess = "Test"
  
  val correctProcessor = allProcessors
    .first { /* 确保此处过滤逻辑能准确匹配到可处理当前元素类型的处理器 */ true }
  
  correctProcessor.processElement(elementToProcess)
}

注意：必须保证过滤逻辑的严谨性，确保找到的处理器确实能处理当前元素类型，否则as T会抛出类型转换异常。

方案2：显式类型判断与智能转换 #

如果无法修改原Processor接口，可以在调用时通过显式类型判断，利用Kotlin的智能转换特性安全调用：

fun main() {
  val allProcessors = listOf(StringProcessor(), IntProcessor())
  val elementToProcess = "Test"
  
  val correctProcessor = allProcessors
    .first { /* 类型匹配逻辑 */ true }
  
  // 通过when语句显式判断处理器类型，触发智能转换
  when (correctProcessor) {
    is Processor<String> -> correctProcessor.process(elementToProcess)
    is Processor<Int> -> {
      // 过滤逻辑需保证走到此处时元素类型为Int
      if (elementToProcess is Int) correctProcessor.process(elementToProcess)
    }
    // 为其他50+处理器类型添加对应分支...
  }
}

缺点：处理器类型较多时需要编写大量分支，维护成本高，仅适合类型数量较少的场景。

方案3：用类型令牌包装处理器 #

创建一个包装类存储处理器实例和对应的类型信息，过滤时通过类型令牌匹配元素类型，调用时安全转换：

import kotlin.reflect.KClass

// 包装类，持有处理器实例与对应的类型令牌
class TypedProcessor<T : Any>(val targetType: KClass<T>, val processor: Processor<T>)

fun main() {
  // 初始化时将处理器包装为TypedProcessor实例
  val allProcessors = listOf(
    TypedProcessor(String::class, StringProcessor()),
    TypedProcessor(Int::class, IntProcessor())
    // 其他处理器的包装实例...
  )
  
  val elementToProcess: Any = "Test"
  
  // 通过元素类型匹配对应的TypedProcessor
  val typedProcessor = allProcessors
    .first { it.targetType.isInstance(elementToProcess) }
  
  // 安全调用，已通过过滤逻辑保证类型匹配
  @Suppress("UNCHECKED_CAST")
  typedProcessor.processor.process(elementToProcess as T)
}

优势：无需修改原接口，类型安全且维护成本低，新增处理器时只需同步添加包装实例即可。

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