Java的浅拷贝与深拷贝

一、概念

浅拷贝
- 浅拷贝仅仅复制所考虑的对象（包括对象中的基本变量），而不复制它所引用的对象。
深拷贝
- 深拷贝把要复制的对象所引用的对象都复制了一遍，并拷贝属性指向的动态分配的内存。
简单描述一下，就是浅拷贝引用了同一个对象地址，而深拷贝却是一个新的对象。

二、问题来源

在一个web请求接口中，返回对象多次封装了同一个结合，导致返回json中的内容体出现了$ref。

问题重现：

定义一个Student(String name,Age age)，Age(Integer age)类

public static void main(String[] args) {
    Student student1 = new Student("张三",new Age(14));
    Student student2 = new Student("李四",new Age(15));
    List son = Arrays.asList(student1,student2);
    List<List> father = new ArrayList<>();
    father.add(son);
    father.add(son);
    System.out.println(JSON.toJSONString(father));
    System.out.println(JSON.toJSONString(father, SerializerFeature.DisableCircularReferenceDetect));
}
//[[{"age":14,"name":"张三"},{"age":15,"name":"李四"}],{"$ref":"$[0]"}]
//[[{"age":14,"name":"张三"},{"age":15,"name":"李四"}],[{"age":14,"name":"张三"},{"age":15,"name":"李四"}]]

FastJson循环引用问题

解决方案一：

简单转换

System.out.println(JSON.toJSONString(father, SerializerFeature.DisableCircularReferenceDetect));

配置SpringBoot项目中的json序列化配置

fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);

解决方案二：
- 创建新对象，不循环引用。

当然，最好的解决办法是创建对象，FastJson提供了一个监测机制，防止循环解析导致StackOverflowError。某一次的问题可以判断为不是循环引用，但无法保证下一次的循环引用。把监测关了，下一次就可能出现StackOverflowError。避免这个问题，就要创建新的对象。于是就来到了数据的拷贝。

三、拷贝

先定义一个基本对象

public class CopyObject implements Cloneable{
    // 基本类型
    private String name;
    // 引用类型
    private StringBuilder add;

    public CopyObject(String name, StringBuilder add) {
        this.name = name;
        this.add = add;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public StringBuilder getAdd() {
        return add;
    }

    public void setAdd(StringBuilder add) {
        this.add = add;
    }

    // 浅拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

3.1 浅拷贝

复制基本数据类型

引用老的引用数据类型

Student、Age类实现CloneAble接口，重写实现clone() 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }


public static void main(String[] args) throws CloneNotSupportedException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
    Age age = new Age(13);
    Student source = new Student("a", age);
    Student target = (Student) source.clone();
    Student target =  SerializationUtils.clone(source);
    Student target = JSONObject.parseObject(JSONObject.toJSONString(source), Student.class);
    System.out.println("step1 =====================");
    System.out.println("source:" + source.getName() + "  " + source.getAge().getAge());
    //source:a  13
    System.out.println("target:" + target.getName() + "  " + target.getAge().getAge());
    target.setName("b");
    //target:a  13
    target.getAge().setAge(15);
    System.out.println("step2 =====================");
    System.out.println("source:" + source.getName() + "  " + source.getAge().getAge());
    //source:a  15
    System.out.println("target:" + target.getName() + "  " + target.getAge().getAge());
    //target:a  15
}

图解：

ShallowCopy

3.1 深拷贝

复制所有的的引用数据类型

重写Student的实现clone() 
    @Override
    protected Student clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.setAge((Age) age.clone());
        return student;
    }

public static void main(String[] args) throws CloneNotSupportedException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
    Age age = new Age(13);
    Student source = new Student("a", age);
    //        Student target = (Student) source.clone();
    //        Student target =  SerializationUtils.clone(source);
    Student target = JSONObject.parseObject(JSONObject.toJSONString(source), Student.class);
    System.out.println("step1 =====================");
    System.out.println("source:" + source.getName() + "  " + source.getAge().getAge());
    //source:a  13
    System.out.println("target:" + target.getName() + "  " + target.getAge().getAge());
    //target:a  13
    target.setName("b");
    target.getAge().setAge(15);
    System.out.println("step2 =====================");
    System.out.println("source:" + source.getName() + "  " + source.getAge().getAge());
    //source:a  13
    System.out.println("target:" + target.getName() + "  " + target.getAge().getAge());
    //target:b  15
}

图解：

DeepCopy

四、实现

浅拷贝
- 默认Object就带有clone方法，但是属于protect。
- 需要实现Cloneable工具类之后，重现clone方法。
- 也有许多其他的工具类提供序列化，使用的时候一定要注意原理，再使用。
深拷贝
- 序列化与反序列化的机制存在下，会保证对象完成不一样。
1. 利用common-lang序列化工具clone工具：
```
// Student、Age需要实现Serializable
 Student targetShallow =  SerializationUtils.clone(source);
```
2. 对于复杂的数组对象无法直接序列化，也可使用JSON序列化之后，再反序列化
```
 Student target = JSONObject.parseObject(JSONObject.toJSONString(source), Student.class);
```
【强制】避免用 Apache Beanutils 进行属性的 copy。（阿里巴巴Java开发手册）
- Apache BeanUtils 性能较差，可以使用其他方案比如 Spring BeanUtils, Cglib BeanCopier，注意均是浅拷贝。

本篇文章由一文多发平台ArtiPub自动发布