深拷贝和浅拷贝的区别，以及BeanUtils为什么是浅拷贝

深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是编程中复制对象时的两种不同方式，核心区别在于是否递归复制对象内部的引用类型成员。

一、浅拷贝（Shallow Copy）

✅ 定义：

• 创建一个新对象。
• 基本数据类型（如int、String、boolean）的值会被直接复制（值拷贝）。
• 引用类型（如对象、数组、List）只复制引用地址，不复制实际对象。

🧠 内存效果：

原对象 A ────┬──→ 基本字段：10（独立） └──→ 引用字段：Addr@123（指向堆中地址对象） 浅拷贝 B ───┬──→ 基本字段：10（独立副本） └──→ 引用字段：Addr@123（和 A 共享同一个地址对象！）

⚠️ 特点：

• 修改基本类型字段：互不影响。
• 修改引用类型字段的内容（如address.city = "上海"）：会影响原对象！

💡 示例（Java）：

class Address { String city; } class Person { String name; Address address; } // 浅拷贝（使用 clone() 默认行为） Person p1 = new Person(); p1.name = "张三"; p1.address = new Address(); p1.address.city = "北京"; Person p2 = (Person) p1.clone(); // 浅拷贝 p2.address.city = "上海"; // 修改引用对象 System.out.println(p1.address.city); // 输出 "上海" → 被影响了！

二、深拷贝（Deep Copy）

✅ 定义：

• 创建一个全新的对象。
• 递归复制所有层级：不仅复制对象本身，还复制它引用的所有对象（子对象、孙子对象……）。
• 新旧对象完全独立，没有任何共享引用。

🧠 内存效果：

原对象 A ───→ Addr@123（city="北京"） 深拷贝 B ───→ Addr@456（city="北京"）← 全新对象！

✅ 特点：

• 修改任何字段（包括嵌套对象）：都不会影响原对象。

💡 示例（Java 手动实现）：

class Address implements Cloneable { String city; public Address deepCopy() { Address a = new Address(); a.city = this.city; return a; } } class Person { String name; Address address; public Person deepCopy() { Person p = new Person(); p.name = this.name; p.address = this.address.deepCopy(); // 关键：也拷贝子对象 return p; } } Person p1 = new Person(); p1.address = new Address(); p1.address.city = "北京"; Person p2 = p1.deepCopy(); p2.address.city = "上海"; System.out.println(p1.address.city); // 输出 "北京" → 不受影响！

三、对比总结

四、常见语言中的实现方式

JavaScript

• 浅拷贝：{...obj},Object.assign(),arr.slice()
• 深拷贝：
  • JSON.parse(JSON.stringify(obj))（有局限）
  • structuredClone(obj)（现代浏览器）
  • _.cloneDeep()（Lodash 库）

Python

• 浅拷贝：copy.copy(obj)
• 深拷贝：copy.deepcopy(obj)

Java

• 浅拷贝：Object.clone()（默认）
• 深拷贝：
  • 重写clone()并递归克隆引用字段
  • 序列化/反序列化（要求实现Serializable）

五、一句话记住

浅拷贝：只复制“外壳”，内部对象共享。
深拷贝：复制“整个家族”，完全独立。

当你需要完全隔离的数据副本（如导出、快照、撤销操作），用深拷贝；
如果只是临时读取或性能敏感，且不会修改嵌套对象，可用浅拷贝。

BeanUtils.copyProperties()不是深拷贝，而是典型的浅拷贝（Shallow Copy）。

✅ 官方结论

无论是Spring Framework 的org.springframework.beans.BeanUtils.copyProperties，
还是Apache Commons BeanUtils 的org.apache.commons.beanutils.BeanUtils.copyProperties，
它们都只执行浅拷贝。

🔍 什么是“浅拷贝”在此处的含义？

• 对于基本数据类型（如int,String,Boolean）：
  值会被复制到目标对象 → 修改互不影响 ✅
• 对于引用类型（如Address,List, 自定义对象）：
  只复制引用地址，不创建新对象 → 源对象和目标对象共享同一个子对象实例❌

这意味着：

如果你修改了目标对象中某个嵌套对象的属性，源对象也会被影响！

🧪 示例说明（使用 Spring BeanUtils）

// 定义类 class Address { private String city; // getter/setter } class Person { private String name; private Address address; // getter/setter }

// 使用 copyProperties Person source = new Person(); source.setName("张三"); source.setAddress(new Address()); source.getAddress().setCity("北京"); Person target = new Person(); BeanUtils.copyProperties(source, target); // 浅拷贝！ // 修改 target 的嵌套对象 target.getAddress().setCity("上海"); // 结果： System.out.println(source.getAddress().getCity()); // 输出 "上海"！ System.out.println(target.getAddress().getCity()); // 输出 "上海"

💥 两个对象的address字段指向同一个Address实例，因此修改一个会影响另一个。

⚠️ 为什么不是深拷贝？

BeanUtils.copyProperties的工作原理是：

1. 通过反射获取源对象的getter 方法
2. 调用目标对象的setter 方法
3. 直接赋值返回的对象引用

它不会递归地为每个引用类型字段创建新实例，因此无法实现深拷贝 。

✅ 如何实现真正的深拷贝？

如果你需要深拷贝，可以考虑以下方案：

示例（Jackson 深拷贝）：

ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(source); Target target = mapper.readValue(json, Target.class); // 真正的深拷贝

📌 总结

💡最佳实践：
当你的 DTO/Entity没有嵌套对象，或嵌套对象不会被修改时，BeanUtils.copyProperties是安全高效的；
一旦涉及可变的复杂对象图，请改用深拷贝方案 。