Java 8中如何避免自动生成相似FaultType类的转换代码重复？

• 存在多个不同包下的FaultType类（如com.test.package1.FaultType、com.test.package2.FaultType），结构当前完全一致但未来可能变动，且为自动生成不可修改。
• 已自定义CustomFault类用于接收这些FaultType实例的字段值：

public class CustomFault {
    private String type;
    private int number;
    private String description;
    private String retryAfter;
    private String system;
    private String nativeError;
    private String nativeDescription;

    // 需补充对应的setter方法
}

• 当前有多个重复的转换方法，需用Java 8实现通用方法消除重复：

CustomFault transformFault(com.test.package1.FaultType fault) {
 // 重复的转换逻辑
}

CustomFault transformFault(com.test.package2.FaultType fault) {
 // 重复的转换逻辑
}

方法一：函数式接口+泛型（类型安全，推荐） #

利用Java 8的Lambda和方法引用，将字段提取逻辑与通用转换逻辑分离：

1. 编写通用转换方法，接收泛型实例和各字段的提取函数：

public <T> CustomFault transformFault(T fault,
                                      Function<T, String> typeExtractor,
                                      Function<T, Integer> numberExtractor,
                                      Function<T, String> descriptionExtractor,
                                      Function<T, String> retryAfterExtractor,
                                      Function<T, String> systemExtractor,
                                      Function<T, String> nativeErrorExtractor,
                                      Function<T, String> nativeDescriptionExtractor) {
    CustomFault customFault = new CustomFault();
    customFault.setType(typeExtractor.apply(fault));
    customFault.setNumber(numberExtractor.apply(fault));
    customFault.setDescription(descriptionExtractor.apply(fault));
    customFault.setRetryAfter(retryAfterExtractor.apply(fault));
    customFault.setSystem(systemExtractor.apply(fault));
    customFault.setNativeError(nativeErrorExtractor.apply(fault));
    customFault.setNativeDescription(nativeDescriptionExtractor.apply(fault));
    return customFault;
}

2. 调用时直接传递对应FaultType的getter方法引用：

// 转换package1的FaultType
CustomFault result1 = transformFault(package1Fault,
                                     com.test.package1.FaultType::getType,
                                     com.test.package1.FaultType::getNumber,
                                     com.test.package1.FaultType::getDescription,
                                     com.test.package1.FaultType::getRetryAfter,
                                     com.test.package1.FaultType::getSystem,
                                     com.test.package1.FaultType::getNativeError,
                                     com.test.package1.FaultType::getNativeDescription);

// 转换package2的FaultType
CustomFault result2 = transformFault(package2Fault,
                                     com.test.package2.FaultType::getType,
                                     com.test.package2.FaultType::getNumber,
                                     com.test.package2.FaultType::getDescription,
                                     com.test.package2.FaultType::getRetryAfter,
                                     com.test.package2.FaultType::getSystem,
                                     com.test.package2.FaultType::getNativeError,
                                     com.test.package2.FaultType::getNativeDescription);

此方式类型安全，后续某类FaultType结构变动时，仅需调整对应方法引用即可，不影响全局转换逻辑。

方法二：反射实现（不推荐，性能低、依赖字段一致性） #

若所有FaultType的字段名、类型完全匹配，可通过反射批量复制字段：

public <T> CustomFault transformFault(T fault) throws IllegalAccessException {
    CustomFault customFault = new CustomFault();
    Field[] faultFields = fault.getClass().getDeclaredFields();
    Field[] customFields = CustomFault.class.getDeclaredFields();

    for (Field customField : customFields) {
        for (Field faultField : faultFields) {
            if (customField.getName().equals(faultField.getName()) &&
                customField.getType().equals(faultField.getType())) {
                faultField.setAccessible(true);
                customField.setAccessible(true);
                customField.set(customFault, faultField.get(fault));
                break;
            }
        }
    }
    return customFault;
}

注意：该方式强依赖字段名和类型完全一致，后续字段变动会导致复制失败，且反射性能远低于直接调用getter，仅适合字段稳定、性能要求低的场景。

方法三：适配器模式（扩展性强，适合未来结构变动） #

通过定义统一接口隔离不同FaultType的差异：

1. 定义统一的Fault接口：

public interface Fault {
    String getType();
    int getNumber();
    String getDescription();
    String getRetryAfter();
    String getSystem();
    String getNativeError();
    String getNativeDescription();
}

2. 为每个FaultType编写适配器类：

public class Package1FaultAdapter implements Fault {
    private final com.test.package1.FaultType fault;

    public Package1FaultAdapter(com.test.package1.FaultType fault) {
        this.fault = fault;
    }

    @Override
    public String getType() {
        return fault.getType();
    }

    @Override
    public int getNumber() {
        return fault.getNumber();
    }

    // 实现其他接口方法，调用对应FaultType的getter
}

// 同理编写Package2FaultAdapter、Package3FaultAdapter

3. 通用转换方法接收Fault接口实例：

public CustomFault transformFault(Fault fault) {
    CustomFault customFault = new CustomFault();
    customFault.setType(fault.getType());
    customFault.setNumber(fault.getNumber());
    customFault.setDescription(fault.getDescription());
    customFault.setRetryAfter(fault.getRetryAfter());
    customFault.setSystem(fault.getSystem());
    customFault.setNativeError(fault.getNativeError());
    customFault.setNativeDescription(fault.getNativeDescription());
    return customFault;
}

4. 调用时用适配器包装FaultType实例：

CustomFault result = transformFault(new Package1FaultAdapter(package1Fault));

此方式扩展性最优，后续某类FaultType结构变动时，仅需修改对应适配器类，通用转换逻辑无需改动。

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