深拷贝（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); // 输出 "北京" → 不受影响！三、对比总结
| 特性 | 浅拷贝 | 深拷贝 |
|---|---|---|
| 基本类型字段 | 复制值（独立） | 复制值（独立） |
| 引用类型字段 | 复制引用（共享对象） | 复制对象（全新实例） |
| 内存占用 | 少 | 多 |
| 性能 | 快 | 慢（需递归） |
| 修改影响 | 可能互相影响 | 完全独立 |
| 实现难度 | 简单（如clone()） | 复杂（需递归或序列化） |
四、常见语言中的实现方式
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的工作原理是：
- 通过反射获取源对象的getter 方法
- 调用目标对象的setter 方法
- 直接赋值返回的对象引用
它不会递归地为每个引用类型字段创建新实例，因此无法实现深拷贝 。
✅ 如何实现真正的深拷贝？
如果你需要深拷贝，可以考虑以下方案：
| 方法 | 说明 | 缺点 |
|---|---|---|
| 手动逐层复制 | 在 setter 中 new 子对象并复制属性 | 代码冗长，维护成本高 |
| 序列化/反序列化 | 使用ObjectOutputStream或 FastJSON/Jackson | 要求所有类实现Serializable，性能较差 |
| 第三方库 | 如 Dozer、ModelMapper、MapStruct | 需引入依赖，学习成本 |
| JSON 中转（慎用） | JSON.parseObject(JSON.toJSONString(obj), Clazz) | 可能丢失类型信息（如 Date 变时间戳），且有性能开销 |
示例（Jackson 深拷贝）：
ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(source); Target target = mapper.readValue(json, Target.class); // 真正的深拷贝📌 总结
| 问题 | 回答 |
|---|---|
BeanUtils.copyProperties是深拷贝吗？ | ❌不是，是浅拷贝 |
| 能否用于含嵌套对象的 DTO 转换？ | ⚠️可以，但要确保后续不修改嵌套对象，否则会污染源数据 |
| 修改目标对象会影响源对象吗？ | ✅如果修改的是引用类型的内部状态，会！ |
| 推荐在什么场景使用？ | ✅ 仅包含基本类型或不可变对象（如String）的 POJO 复制 |
💡最佳实践：
当你的 DTO/Entity没有嵌套对象，或嵌套对象不会被修改时，BeanUtils.copyProperties是安全高效的；
一旦涉及可变的复杂对象图，请改用深拷贝方案 。
