如何处理对两个字段相同的第三方Java对象执行相同操作的场景

嘿，我太懂你这种无奈了！第三方依赖的对象咱们根本没法修改，就像你举的例子，Object_A和Object_B明明字段完全一样，却偏偏是两个独立的类，每次对它们做相同操作都要写重复代码，实在太繁琐了。

先看看你提到的这两个第三方类：

public class Object_A {
    private String foo;
    private String bar;
    
    // 假设第三方类提供了标准getter方法
    public String getFoo() { return foo; }
    public String getBar() { return bar; }
}

public class Object_B {
    private String foo;
    private String bar;
    
    // 同样提供标准getter方法
    public String getFoo() { return foo; }
    public String getBar() { return bar; }
}

既然没法修改原类，咱们可以从复用逻辑的角度入手，给你几个实用的解决思路：

方案一：用反射提取通用工具方法 #

如果操作逻辑比较简单，反射是个快速解决的办法。咱们可以写一个工具类，把对foo和bar的操作逻辑抽出来，通过反射获取字段值，不用管是哪个类的对象：

public class ThirdPartyObjectHandler {
    public static void processCommonFields(Object obj) {
        try {
            // 通过反射调用getter获取字段值
            String foo = (String) obj.getClass().getMethod("getFoo").invoke(obj);
            String bar = (String) obj.getClass().getMethod("getBar").invoke(obj);
            
            // 这里写你的通用操作逻辑
            System.out.println("处理foo: " + foo + ", 处理bar: " + bar);
        } catch (Exception e) {
            // 处理反射异常，比如对象没有对应getter的情况
            e.printStackTrace();
        }
    }
}

// 使用的时候直接传任意一个对象就行
ThirdPartyObjectHandler.processCommonFields(objectA);
ThirdPartyObjectHandler.processCommonFields(objectB);

不过要注意，反射会有一点性能损耗，如果是高频调用的场景，可能要考虑其他方案。

方案二：统一转换为自定义DTO #

咱们可以自己定义一个和第三方类字段一致的DTO，把Object_A和Object_B都转成这个DTO，然后只针对DTO写一次操作逻辑：

// 自定义的通用DTO
public class CommonObject {
    private String foo;
    private String bar;
    
    // 构造方法、getter、setter
    public CommonObject(String foo, String bar) {
        this.foo = foo;
        this.bar = bar;
    }
    
    // 省略getter和setter实现
}

// 写个转换器，把第三方对象转成DTO
public class ObjectConverter {
    public static CommonObject convertToCommon(Object_A objA) {
        return new CommonObject(objA.getFoo(), objA.getBar());
    }
    
    public static CommonObject convertToCommon(Object_B objB) {
        return new CommonObject(objB.getFoo(), objB.getBar());
    }
}

// 操作逻辑只需要写一次
public void processCommonObject(CommonObject commonObj) {
    // 你的通用操作
    System.out.println("处理通用对象的foo: " + commonObj.getFoo());
}

// 使用的时候先转换再处理
processCommonObject(ObjectConverter.convertToCommon(objectA));
processCommonObject(ObjectConverter.convertToCommon(objectB));

这个方案更清晰，也避免了反射的性能问题，适合逻辑比较复杂的场景。如果转换逻辑多，还可以用ModelMapper这类映射工具简化转换代码哦。

方案三：利用函数式接口复用逻辑 #

Java 8及以上的函数式接口可以帮咱们把字段的获取逻辑抽象出来，不用关心具体是哪个对象：

// 定义通用的处理方法，接收获取foo和bar的函数
public void processFields(Supplier<String> fooSupplier, Supplier<String> barSupplier) {
    String foo = fooSupplier.get();
    String bar = barSupplier.get();
    
    // 通用操作逻辑
    System.out.println("处理foo: " + foo + ", 处理bar: " + bar);
}

// 使用的时候直接传入方法引用
processFields(objectA::getFoo, objectA::getBar);
processFields(objectB::getFoo, objectB::getBar);

这种方式很灵活，不用写额外的工具类或DTO，代码也很简洁，适合简单的操作场景。

这些方法都能帮你摆脱重复代码的困扰，选哪种完全看你的业务场景复杂度和性能要求啦～

内容来源于stack exchange