自定义Copyable接口替代Cloneable实现对象拷贝是否可行？

绝对是个靠谱的思路，甚至可以说是泛型场景下处理对象拷贝的最佳实践之一。你提到的Cloneable确实有一堆历史遗留问题：它只是个标记接口，本身没有定义clone()方法，实现时还要处理烦人的CloneNotSupportedException；clone()默认是protected的，必须手动改成public；浅拷贝/深拷贝的行为完全不透明，很容易踩坑。而自定义Copyable接口刚好能避开这些痛点，让拷贝逻辑清晰、类型安全，还能在泛型代码里放心调用。

具体实现步骤 #

1. 定义Copyable接口 #

先搞一个简单的接口，明确约定拷贝行为：

public interface Copyable<T> {
    // 返回当前对象的副本，子类需明确实现浅/深拷贝逻辑
    T copy();
}

2. 修改DangerousCallWrapper的泛型约束 #

让泛型T必须实现Copyable，这样就能在方法里安全调用copy()获取对象副本：

public class DangerousCallWrapper<T extends Copyable<T>> implements DangerousCaller<T> {
    private final DangerousService<T> service;

    // 建议用构造器注入服务，避免硬编码依赖
    public DangerousCallWrapper(DangerousService<T> service) {
        this.service = service;
    }

    @Override
    public T doThing(T dataObject) {
        // 调用copy()拿到副本，原对象完全不受第三方服务影响
        T cloneOfDataObject = dataObject.copy();
        T result = service.doThing(cloneOfDataObject);
        return Optional.ofNullable(result)
                .orElseThrow(() -> new RuntimeException("No data object returned"));
    }
}

3. 让业务类实现Copyable #

以ImportantObj为例，明确实现copy()方法，根据需求选择浅拷贝或深拷贝：

public class ImportantObj implements Copyable<ImportantObj> {
    private String importantField;
    private String thing;

    // 链式setter方法
    public ImportantObj setImportantField(String importantField) {
        this.importantField = importantField;
        return this;
    }

    public ImportantObj setThing(String thing) {
        this.thing = thing;
        return this;
    }

    // Getters（建议添加，方便字段访问）
    public String getImportantField() {
        return importantField;
    }

    public String getThing() {
        return thing;
    }

    @Override
    public ImportantObj copy() {
        // 这里做浅拷贝，如果有引用类型字段，需要改成递归拷贝实现深拷贝
        ImportantObj copy = new ImportantObj();
        copy.setImportantField(this.importantField);
        copy.setThing(this.thing);
        return copy;
    }
}

4. 验证逻辑正确性 #

修改后的main方法可以完美保护原对象：

public static void main(String[] args) {
    // 直接调用服务，原对象会被修改
    DangerousService<ImportantObj> service = new DangerousService<>();
    ImportantObj important1 = new ImportantObj()
            .setImportantField("Password for my bank account")
            .setThing("Undone");
    service.doThing(important1);
    System.out.println(important1.getImportantField() == null); // 输出true，原字段被修改

    // 使用Wrapper，原对象不受影响
    DangerousCallWrapper<ImportantObj> wrapper = new DangerousCallWrapper<>(service);
    ImportantObj important2 = new ImportantObj()
            .setImportantField("Password for my bank account")
            .setThing("Undone");
    wrapper.doThing(important2);
    System.out.println(important2.getImportantField() != null); // 输出true，原字段完好
}

额外优化建议 #

• 如果很多类需要实现拷贝，可以写一个抽象类封装通用逻辑（比如结合反射或Jackson序列化），减少重复代码。
• 若需要深拷贝，在copy()方法里要递归拷贝所有引用类型字段；或者用序列化/反序列化的方式（比如Jackson），但要确保类实现Serializable接口。
• 可以给Copyable接口添加默认方法，结合拷贝构造器使用，让子类只需要实现拷贝构造器即可：

public interface Copyable<T> {
    T copy();

    // 默认方法：基于拷贝构造器实现拷贝
    default T copyFromConstructor() {
        try {
            Constructor<T> constructor = (Constructor<T>) this.getClass().getConstructor(this.getClass());
            return constructor.newInstance(this);
        } catch (Exception e) {
            throw new RuntimeException("Failed to copy object via constructor", e);
        }
    }
}

然后ImportantObj可以这样实现：

public class ImportantObj implements Copyable<ImportantObj> {
    // 拷贝构造器
    public ImportantObj(ImportantObj other) {
        this.importantField = other.importantField;
        this.thing = other.thing;
    }

    // 默认构造器（按需添加）
    public ImportantObj() {}

    @Override
    public ImportantObj copy() {
        return copyFromConstructor();
    }

    // ...其他方法
}

这种方式结合了拷贝构造器的安全性，又通过接口统一了泛型场景下的调用方式，非常灵活。

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