我们应该使用 clone 还是 BeanUtils.copyProperties 以及为什么

Josh Bloch提供了一些相当不错的论据（包括你提供的那个），断言从根本上是有缺陷的，而是倾向于复制构造函数。请参阅此处。Cloneable

我还没有遇到复制不可变对象的实际用例。您出于特定原因复制对象，大概是为了将一组可变对象隔离到单个事务中进行处理，从而保证在该处理单元完成之前，没有任何内容可以更改它们。如果它们已经是不可变的，那么引用与副本一样好。

BeanUtils.copyProperties通常是一种侵入性较小的复制方式，无需更改要支持的类，并且在合成对象时提供了一些独特的灵活性。

也就是说，并不总是一刀切的。在某些时候，您可能需要支持包含具有专用构造函数但仍可变类型的类型的对象。您的对象可以支持内部方法或构造函数来解决这些异常，或者您可以将特定类型注册到某些外部工具中以进行复制，但它无法到达某些甚至可以访问的地方。这很好，但仍然有局限性。copyPropertiesclone()

我已经检查了源代码，我发现它只是复制了基元属性的“第一级”。当涉及到嵌套对象时，嵌套属性仍然引用原始对象的字段，因此它不是“深层副本”。

检查来自 Spring 源代码的以下片段，版本 5.1.3：org.springframework.beans.BeanUtils.java

/**
     * Copy the property values of the given source bean into the target bean.
     * <p>Note: The source and target classes do not have to match or even be derived
     * from each other, as long as the properties match. Any bean properties that the
     * source bean exposes but the target bean does not will silently be ignored.
     * <p>This is just a convenience method. For more complex transfer needs,
     * consider using a full BeanWrapper.
     * @param source the source bean
     * @param target the target bean
     * @throws BeansException if the copying failed
     * @see BeanWrapper
     */
    public static void copyProperties(Object source, Object target) throws BeansException {
        copyProperties(source, target, null, (String[]) null);
    }

...

    /**
     * Copy the property values of the given source bean into the given target bean.
     * <p>Note: The source and target classes do not have to match or even be derived
     * from each other, as long as the properties match. Any bean properties that the
     * source bean exposes but the target bean does not will silently be ignored.
     * @param source the source bean
     * @param target the target bean
     * @param editable the class (or interface) to restrict property setting to
     * @param ignoreProperties array of property names to ignore
     * @throws BeansException if the copying failed
     * @see BeanWrapper
     */
    private static void copyProperties(Object source, Object target, @Nullable Class<?> editable,
            @Nullable String... ignoreProperties) throws BeansException {

        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");

        Class<?> actualEditable = target.getClass();
        if (editable != null) {
            if (!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                        "] not assignable to Editable class [" + editable.getName() + "]");
            }
            actualEditable = editable;
        }
        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);

        for (PropertyDescriptor targetPd : targetPds) {
            Method writeMethod = targetPd.getWriteMethod();
            if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if (sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if (readMethod != null &&
                            ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                        try {
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                readMethod.setAccessible(true);
                            }
                            Object value = readMethod.invoke(source);
                            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                writeMethod.setAccessible(true);
                            }
                            writeMethod.invoke(target, value);
                        }
                        catch (Throwable ex) {
                            throw new FatalBeanException(
                                    "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                        }
                    }
                }
            }
        }
    }

只需关注以下几行：

Object value = readMethod.invoke(source);
...
writeMethod.invoke(target, value);

此行调用目标对象上的 setter。想象一下这门课：

class Student {
    private String name;
    private Address address;
}

如果我们有 和 ，则第二个只是被加密，没有分配任何字段，has 和 name 。student1student2student1address1John

因此，如果我们调用：

    BeanUtils.copyProperties(student1, student2);

我们正在做：

    student2.setName(student1.getName()); // this is copy because String is immutable
    student2.setAddress(student1.getAddress()); // this is NOT copy, we still are referencing `address1`

当变化时，它也改变了。address1student2

因此，仅适用于对象的基元类型字段;如果它是嵌套的，它不起作用;或者，您必须确保原始对象在目标对象的整个生命周期中的不可变性，这并不容易和可取。BeanUtils.copyProperties()

如果你真的想让它成为一个深度副本，你必须实现某种方法来对不是基元的字段递归调用此方法。最后，您将到达一个只有基元/不可变字段的类，然后您就完成了。