如何为不同包下的两个XSD生成类编写通用方法？

这种由XSD生成的“同功能、同方法签名但不同包”的类，我之前做SOAP接口开发时经常碰到，完全不用重复写两遍业务逻辑，下面给你几个实用的解决思路：

方案一：定义统一接口+适配器类（类型安全首选） #

这是最稳妥的方式，通过接口统一行为，适配器做包类的转换，通用方法只需要面向接口开发。

1. 定义公共接口 #

先把两个类的公共方法抽成一个接口：

public interface XBehavior {
    void m();
    int n();
    String o();
}

2. 编写适配器类 #

给每个包的X类写适配器，把它们的方法委托给接口：

// 适配a.b.c.X的适配器
public class CXAdapter implements XBehavior {
    private final a.b.c.X target;

    public CXAdapter(a.b.c.X target) {
        this.target = target;
    }

    @Override
    public void m() {
        target.m();
    }

    @Override
    public int n() {
        return target.n();
    }

    @Override
    public String o() {
        return target.o();
    }
}

// 适配a.b.d.X的适配器
public class DXAdapter implements XBehavior {
    private final a.b.d.X target;

    public DXAdapter(a.b.d.X target) {
        this.target = target;
    }

    @Override
    public void m() {
        target.m();
    }

    @Override
    public int n() {
        return target.n();
    }

    @Override
    public String o() {
        return target.o();
    }
}

3. 编写通用方法 #

现在通用逻辑只需要接收XBehavior类型的参数，就能同时处理两个包的类：

public class XProcessor {
    public void process(XBehavior x) {
        x.m();
        int resultNum = x.n();
        String resultStr = x.o();
        // 这里写你的通用业务逻辑
        System.out.println("处理结果：数字=" + resultNum + "，字符串=" + resultStr);
    }
}

使用的时候只需要把实例包装进适配器：

a.b.c.X cx = new a.b.c.X();
new XProcessor().process(new CXAdapter(cx));

a.b.d.X dx = new a.b.d.X();
new XProcessor().process(new DXAdapter(dx));

方案二：反射实现无适配通用方法（快速实现） #

如果不想写适配器类，也可以用反射直接调用方法，缺点是失去编译时类型检查，但代码量最少：

public class XProcessor {
    public void process(Object x) throws Exception {
        // 调用无参方法m
        x.getClass().getMethod("m").invoke(x);
        // 调用返回int的方法n
        int resultNum = (int) x.getClass().getMethod("n").invoke(x);
        // 调用返回String的方法o
        String resultStr = (String) x.getClass().getMethod("o").invoke(x);
        
        // 通用业务逻辑
        System.out.println("处理结果：数字=" + resultNum + "，字符串=" + resultStr);
    }
}

使用时直接传入两个类的实例即可：

new XProcessor().process(new a.b.c.X());
new XProcessor().process(new a.b.d.X());

方案三：泛型+方法引用（Java 8+简洁写法） #

如果你的通用逻辑只是简单调用这些方法并处理返回值，可以用方法引用简化，不用写适配器：

public class XProcessor {
    public <T> void process(T x, Runnable mAction, Supplier<Integer> nSupplier, Supplier<String> oSupplier) {
        mAction.run();
        int resultNum = nSupplier.get();
        String resultStr = oSupplier.get();
        
        // 通用业务逻辑
        System.out.println("处理结果：数字=" + resultNum + "，字符串=" + resultStr);
    }
}

使用时传入对应方法的引用：

a.b.c.X cx = new a.b.c.X();
new XProcessor().process(cx, cx::m, cx::n, cx::o);

a.b.d.X dx = new a.b.d.X();
new XProcessor().process(dx, dx::m, dx::n, dx::o);

方案选择建议 #

• 追求类型安全、可维护性：选方案一，编译时就能发现问题，后续修改方法签名也能及时感知；
• 想快速实现、代码量少：选方案二，适合逻辑简单、不会频繁修改的场景；
• 喜欢简洁语法：选方案三，Java 8+环境下代码更清爽，没有冗余的适配器类。

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