了解Spring中常见的设计模式-------------------原型模式

原型模式（Prototype Pattern）

是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象；调用者不需要知道任何创建的细节，不调用构造函数；属于创建型模式；

适用场景：

类初始化消耗资源较多；new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）；构造函数比较复杂；

循环体中生成大量的对象；

代码示例：

BeanUtils.copy();

JSON.parseObject();

Guava  copy工具类

浅克隆

需要创建新对象，但是克隆对象中的属性与原对象指向的是同一地址空间，一个对象中的属性值改变会引起其他克隆对象的值的改变；

public interface Prototype {

    Prototype clone();
}



@Data
public class ConcretePrototypeA implements Prototype {
    private String name;
    private List<String> type;

    @Override
    public Prototype clone() {
        ConcretePrototypeA concretePrototypeA = new ConcretePrototypeA();
        concretePrototypeA.setName(this.name);
        concretePrototypeA.setType(this.type);
        return concretePrototypeA;
    }
}



public class SimplePrototypeTest {
    public static void main(String[] args) {
        ConcretePrototypeA concretePrototypeA = new ConcretePrototypeA();
        List<String> list = new ArrayList<>();
        list.add("typeAdd_A");
        concretePrototypeA.setType(list);
        concretePrototypeA.setName("testA");

        ConcretePrototypeA copy = (ConcretePrototypeA)concretePrototypeA.clone();

        System.out.println("原对象："+concretePrototypeA.getType());
        System.out.println("克隆对象："+copy.getType());
        boolean flag = concretePrototypeA.getType()==copy.getType();
        System.out.println("原对象与克隆属性指向的地址是否相等："+flag);

    }
}


测试结果：

原对象：[typeAdd_A]
克隆对象：[typeAdd_A]
原对象与克隆属性指向的地址是否相等：true

深克隆

与单例模式相反，需要重新创建对象，并且将原对象的值赋给新创建的克隆对象，对象属性指向不同的地址空间。

实现方式：

1、可以使用JDK内置的Cloneable方法，需要重写clone()方法；

public interface IDeepPrototype {
    IDeepPrototype clone();
}


@Data
public class DeepPrototypeImpl implements IDeepPrototype, Cloneable, Serializable {
    private String name;
    private List<String> type;

    @Override
    public IDeepPrototype clone() {
        return this.cloneDeep();
    }

    private IDeepPrototype cloneDeep() {
        DeepPrototypeImpl ob = null;
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        System.out.println(this);
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(this);
            objectOutputStream.flush();
            objectOutputStream.close();

            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(outputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            ob = (DeepPrototypeImpl)objectInputStream.readObject();
            System.out.println(ob);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ob;
    }
}



public class DeepPrototypeTest {

    public static void main(String[] args) {
        DeepPrototypeImpl deepPrototype = new DeepPrototypeImpl();
        deepPrototype.setName("test1");
        List<String> list = new ArrayList<>();
        list.add("listAdd1");
        deepPrototype.setType(list);
        System.out.println("原对象：" + deepPrototype.getType());
        try {
            DeepPrototypeImpl deepPrototype1 = (DeepPrototypeImpl)deepPrototype.clone();
            System.out.println("克隆对象：" + deepPrototype1.getType());
            boolean flag = deepPrototype.getType() == deepPrototype1.getType();
            System.out.println("原对象与克隆对象属性是否指向同一地址：" + flag);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果：
原对象：[listAdd1]
DeepPrototypeImpl(name=test1, type=[listAdd1])
DeepPrototypeImpl(name=test1, type=[listAdd1])
克隆对象：[listAdd1]
原对象与克隆对象属性是否指向同一地址：false