原型设计模式

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 测试Spring中的原型设计模式
 */
public class Test {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        Sheep bean = annotationConfigApplicationContext.getBean(Sheep.class);
        System.out.println(bean);

        Sheep newBean = annotationConfigApplicationContext.getBean(Sheep.class);
        System.out.println(newBean);

        System.out.println(bean == newBean);
    }

}

3.2.2原型模式（Scope = prototype）

/**
 * 绵羊类
 */
@Component
@Scope("prototype")
public class Sheep implements Cloneable {

        测试代码和默认模式的时候是一样的，进行测试：

        可以发现这次获取到的Bean对象就是完全不同的Bean对象了，底层设计是原型设计模式。

3.3SpringBean创建的流程分析

4.原型设计模式

4.1浅拷贝的问题所在

4.1.1问题描述

        Object默认进行提供的是浅拷贝的代码。

        浅拷贝是纯的变量拷贝，基本数据类型和引用数据类型进行拷贝都是进行值拷贝，也就是说引用数据类型进行拷贝的时候也仅仅是将变量进行拷贝过去而已，拷贝之后两个对象的引用字段进行指向的都是同一个引用变量，这就是最大的问题。

4.1.2问题测验

4.1.2.1校验代码

        Sheep类还是刚刚哪个类：

/**
 * 绵羊类
 */
public class Sheep implements Cloneable {

    private String name;
    private int age;
    private String color;
    private Sheep friend;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep sheep) {
        friend = sheep;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        sheep = (Sheep) super.clone();
        return sheep;
    }

    @Override
    public String toString() {
        String str = "name = " + name + ", age = " + age + " color = " + color + " 。";
        return str;
    }

}

        测试代码：

        主要是进行检验引用变量进行拷贝后的指向。

import java.util.ArrayList;

/**
 * 测试浅拷贝的问题
 */
public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep();
        sheep.setName("tom");
        sheep.setAge(10);
        sheep.setColor("白色");
        ArrayList<Sheep> list = new ArrayList<>();
        for (int index = 0; index < 10; index++) {
            Sheep sheepClone = (Sheep) sheep.clone();
            list.add(sheepClone);
        }

        System.out.println(sheep);

        for (Sheep item : list) {
            System.out.println(item.getFriend() == sheep.getFriend());
        }
    }

}

4.1.2.2校验结果

4.2深拷贝对问题的解决

        深拷贝对于基本数据类型和浅拷贝的处理方式是一样的，都是对数据的值进行拷贝。 但是深拷贝对对象的处理方式是不一样的。

        深拷贝对对象的处理方式：

        深拷贝会为所有引用数据类型的成员变量进行申请存储空间，并进行复制每个引用数据类型成员变 量锁引用的对象，知道该对象可达的所有对象（对于嵌入的对象处理方式是不一样，进行克隆对象中的对象字段的数据的时候，是根据克隆的对象字段的数据进行选择使用深拷贝还是浅拷贝）

        深拷贝对象的实现方式：

        深拷贝的实现方式1：重写clone方法实现深拷贝。

        深拷贝的实现方式2：通过对象序列化实现深拷贝。

4.3实现深拷贝

4.3.1使用重写clone方法实现深拷贝

4.3.1.1定义内部嵌套引用对象类

        想要使用重写clone方法进行实现深拷贝，里面嵌套的对象也要进行实现Cloneable接口，重写clone 方法。

import java.io.Serializable;

public class DeepCloneableTarget implements Serializable, Cloneable {

    private static final long serialVersionUID = 4548645106533515943L;

    private String cloneName;

    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

4.3.1.2定义外部类 => 内部进行引用对象字段

        引用了DeepCloneableTarget类型的字段。

        进行重写了clone规则，其实深拷贝的原理很简单，内部有需要进行深拷贝的对象字段的时候，调用对象相应的clone方法，进行克隆出来一个对象，并对外部对象的对象字段进行赋值。

        要点：其实就是多层调用clone，不是简简单单的指针转换。

public Object deepClone() throws IOException {

    // 创建流对象
    ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null;

    try {
        // 序列化
        bos = new ByteArrayOutputStream();
        // 创建对象输出流
        oos = new ObjectOutputStream(bos);
        // 将这个对象以流的方式输出
        oos.writeObject(this);

        // 反序列化
        bis = new ByteArrayInputStream(bos.toByteArray());
        ois = new ObjectInputStream(bis);
        DeepProtoType copyObject = (DeepProtoType) ois.readObject();
        return copyObject;
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        bos.close();
        oos.close();
        bis.close();
        ois.close();
    }
    return null;
}

import java.io.IOException;

/**
 * 测试序列化深拷贝
 */
public class TestClient {

    public static void main(String[] args) throws IOException {
        DeepProtoType deepProtoType = new DeepProtoType();
        deepProtoType.name = "大哈哈哈";
        DeepCloneableTarget deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
        deepProtoType.deepCloneableTarget = deepCloneableTarget;

        // 方式二完成深拷贝
        DeepProtoType clone = (DeepProtoType) deepProtoType.deepClone();
        System.out.println(deepProtoType == clone);
        System.out.println(deepProtoType.deepCloneableTarget == clone.deepCloneableTarget);
    }

}

4.3.3使用JSON序列化框架进行深拷贝

4.3.3.1引入JSON序列化框架 => GSON

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

public Object deepCloneJson() {
    Gson gson = new Gson();
    String json = gson.toJson(this);
    return gson.fromJson(json, DeepProtoType.class);
}

// 方式三完成深拷贝
DeepProtoType jsonClone = (DeepProtoType) deepProtoType.deepCloneJson();
System.out.println(deepProtoType == jsonClone);
System.out.println(deepProtoType.deepCloneableTarget == jsonClone.deepCloneableTarget);