java - 创建一个通用函数来复制不同的对象

Question

所以我有一个用例，我需要复制一个object的 class es(类可能因工厂中的输入类型而异。

这是我正在尝试做的示例

public interface DataUtil {

    // the main wrapper 
    static Object copyObject(Object payload){
        if(payload instanceof Human))
            return copyEntry((Human) payload);
        if(payload instanceof Car))
            return copyEntry((Car) payload);
        if(payload instanceof Planet))
            return copyEntry((Planet) payload);        
        return payload;
    }

    static Human copyEntry(Human human) {
        return Human.builder()
                .name(human.getName())
                .age(human.getAge())
                .build();
    }

    static Car copyEntry(Car car) {
        return Car.builder()
                .model(car.getModel())
                .brand(car.getBrand())
                .build();
    }

    static Planet copyEntry(Planet planet) {
        // return builder like previous
    }
}

如果你看copyObject功能，它按预期完成工作，但他的问题是返回类型。目前，为了使其自身兼容，它返回一个Object。但我宁愿返回它特定的类对象(例如 Human 或 Car)

有没有办法通过泛型(使用 <T> )完成这项工作？或者这首先是一种糟糕的方法？

Answer 1

Is there a way to get this done with Generics (using )? or is this a bad approach in the first place to do?

这是一个糟糕的方法，因为您接收到一个 Object 作为参数。
您无法从中推断出具体类型:而您使用的是 instanceof。这不是一个好的方法。
这里有两个想法(足够相关)

1) 引入可复制接口(interface)

您可以引入一个接口(interface)，您要复制的对象的类实现该接口(interface):

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

可以这样实现:

public class Human implements Copyable<Human> {

   @Override
   public Human copy(Human t) {
       return    Human.builder()
                     .name(human.getName())
                     .age(human.getAge())
                     .build();
   }

}

所以一般的 copy() 方法看起来像:

// the main wrapper
static <T extends Copyable<T>> T copyObject(T payload) {
    return payload.copy(payload);
}

你可以这样使用它:

Human human = new Human();
// set some fields  ...
Human copiedHuman = copyObject(human); // compile
Car copiedCar = copyObject(human); // doesn't compile

2) 使用访问者模式

作为替代，它也是访问者模式的一个很好的例子:你想根据参数的具体类型应用处理。
它允许将复制操作分组在一起，就像在您的实际代码中一样。

一般的 copyObject() 方法可以依赖于 CopyVisitor，它会根据参数的具体类型进行复制:

@SuppressWarnings("unchecked")
static <T extends Visited> T copyObject(T payload) {
    CopyVisitor visitor = new CopyVisitor();
    payload.accept(visitor);
    return (T) visitor.getCopy();
}

CopyVisitor 实现了经典的Visitor 接口(interface):

public interface Visitor {  
    void visitHuman(Human human);
    void visitCar(Car car);
    void visitPlanet(Planet planet);
}

这样:

public class CopyVisitor implements Visitor {

    private Visited copy;

    @Override
    public void visitHuman(Human human) {
        copy = Human.builder()
                    .name(human.getName())
                    .age(human.getAge())
                    .build();

    }

    @Override
    public void visitCar(Car car) {
        copy = Car.builder()
                  .model(car.getModel())
                  .brand(car.getBrand())
                  .build();
    }

    @Override
    public void visitPlanet(Planet planet) {
        //...
    }

    public Visited getCopy() {
        return copy;
    }

}

被访问的类(Car、Human、Plan)将实现一个特定的接口(interface)来“接受”访问者:

public interface Visited {
    void accept(Visitor visitor);
}

比如:

public class Human implements Visited {

    @Override
    public void accept(Visitor visitor) {
        visitor.visitHuman(this);
    }

}

所以你可以这样使用copy()方法:

Human human = new Human();
// set some fields  ...
Human copiedHuman = copyObject(human); // compile
Car copiedCar = copyObject(human); // doesn't compile