通过反射创建Mapping接口实现类并完成实例化的技术问题

看起来你已经搭好了一套基于泛型的Mapping接口体系，现在核心困扰是怎么通过反射动态实例化这些Mapping实现类，还要依托getInputClass()和getOutputClass()来处理输入输出的实例化与类型匹配对吧？咱们一步步拆解来解决这个问题。

首先先明确你给出的核心代码结构（方便后续讨论，我还修正了实现类里的一个小错误）：

核心接口与标记类 #

// 空标记接口
public interface Input {}
public interface Output {}

// 泛型Mapping核心接口
public interface Mapping<I extends Input, O extends Output> {
    O calculate(I input);

    Class<I> getInputClass();

    Class<O> getOutputClass();
}

示例实现类与实体类 #

// 输入实体类
public class DoublerInput implements Input {
    private int value;
    // getter/setter
    public int getValue() { return value; }
    public void setValue(int value) { this.value = value; }
}

// 输出实体类
public class DoublerOutput implements Output {
    private int value;
    // getter/setter
    public int getValue() { return value; }
    public void setValue(int value) { this.value = value; }
}

// Mapping实现类（修正了getOutputClass的返回错误）
public class DoublerMapping implements Mapping<DoublerInput, DoublerOutput> {
    @Override
    public DoublerOutput calculate(DoublerInput input){
       DoublerOutput output = new DoublerOutput();
       output.setValue(input.getValue() * 2);
       return output;
    }

    @Override
    public Class<DoublerInput> getInputClass(){
       return DoublerInput.class;
    }

    @Override
    public Class<DoublerOutput> getOutputClass(){
       return DoublerOutput.class;
    }
}

反射实例化的具体步骤与解决方案 #

1. 先实例化Mapping实现类本身

其实这一步很直接，只要拿到实现类的Class对象，调用无参构造方法即可：

// 假设你已知Mapping实现类的全类名
String mappingClassName = "com.yourpackage.DoublerMapping";
Class<?> mappingClass = Class.forName(mappingClassName);
// 实例化并强转为Mapping类型（泛型通配符兼容所有Input/Output子类）
Mapping<? extends Input, ? extends Output> mapping = 
    (Mapping<? extends Input, ? extends Output>) mappingClass.getDeclaredConstructor().newInstance();

2. 依托getInputClass()/getOutputClass()实例化输入输出对象

因为Java泛型存在类型擦除，运行时无法直接从Mapping对象获取泛型参数类型，所以你设计的这两个方法正好用来保存类型信息，用它们来实例化输入输出对象是最优解：

// 实例化输入对象
Input input = mapping.getInputClass().getDeclaredConstructor().newInstance();
// 给输入对象赋值（需要类型判断保证安全）
if (input instanceof DoublerInput) {
    ((DoublerInput) input).setValue(10);
}

// 执行Mapping的计算逻辑
Output output = mapping.calculate(input);

// 处理输出结果
if (output instanceof DoublerOutput) {
    System.out.println("翻倍后的值：" + ((DoublerOutput) output).getValue());
}

关键注意事项 #

• 类型安全：反射得到的Mapping是泛型通配符类型，处理输入输出时一定要用instanceof做类型判断，避免类型转换异常。
• 构造方法权限：如果你的Mapping实现类、输入输出类的构造方法不是public的，需要调用setAccessible(true)来允许反射访问。
• 泛型擦除的影响：这是Java泛型的天生特性，你通过getInputClass()和getOutputClass()保存类型信息的设计非常合理，完美规避了擦除带来的问题。

进阶优化：封装反射工具类 #

如果需要频繁实例化不同的Mapping，可以封装一个工具类简化操作：

public class MappingUtils {
    @SuppressWarnings("unchecked")
    public static <I extends Input, O extends Output> Mapping<I, O> instantiateMapping(Class<? extends Mapping<I, O>> mappingClass) throws Exception {
        return mappingClass.getDeclaredConstructor().newInstance();
    }

    public static <I extends Input> I instantiateInput(Mapping<I, ?> mapping) throws Exception {
        return mapping.getInputClass().getDeclaredConstructor().newInstance();
    }

    public static <O extends Output> O instantiateOutput(Mapping<?, O> mapping) throws Exception {
        return mapping.getOutputClass().getDeclaredConstructor().newInstance();
    }
}

使用起来会更简洁：

Mapping<DoublerInput, DoublerOutput> doublerMapping = MappingUtils.instantiateMapping(DoublerMapping.class);
DoublerInput input = MappingUtils.instantiateInput(doublerMapping);
input.setValue(5);
DoublerOutput output = doublerMapping.calculate(input);
System.out.println(output.getValue()); // 输出10

备注：内容来源于stack exchange，提问作者TdrFlp