原型模式

Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示能够复制且具有复制的能力 => 原型模式。
原型模式就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。它主要应用与那些创建新对象的成本过大时。它的主要优点就是简化了新对象的创建过程，提高了效率，同时原型模式提供了简化的创建结构。
基本介绍：

  • 原型模式是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
  • 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
  • 工作原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()

UML类图：
image-20210329154713751.png

  • ProtoType：原型类，声明一个克隆自己的接口
  • ConcreteProtoType：具体的原型类，实现一个克隆自己的操作
  • Client：让一个原型对象克隆自己，从而创建一个新的对象（属性一样的对象）

代码示例：
创建被克隆的类，并实现Cloneable接口

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Sheep implements Cloneable{
  5.     private String name;
  6.     private Integer age;
  7.     @Override
  8.     protected Sheep clone() {
  9.         Sheep sheep = new Sheep();
  10.         try {
  11.             sheep = (Sheep) super.clone();
  12.         } catch (CloneNotSupportedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         return sheep;
  16.     }
  17. }

客户端调用

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Sheep one = new Sheep("one", 18);
  4.         Sheep two = one.clone();
  5.         Sheep three = one.clone();
  6.         System.out.println(one.toString());
  7.         System.out.println(two.toString());
  8.         System.out.println(three.toString());
  9.     }
  10. }

在Spring中，原型bean的创建，就是原型模式的应用。
浅拷贝：
1、对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
2、对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
3、上述的代码示例就是浅拷贝
4、浅拷贝是使用默认的clone()方法来实现的
深拷贝：
1、复制对象的所有基本数据类型的成员变量
2、为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
3、深拷贝实现方式：重写clone方法实现深拷贝、或者通过对象序列化实现深拷贝
方式一，重写clone方法

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Sheep implements Cloneable{
  5.     private String name;
  6.     private Integer age;
  7.     private Integer[] infos;
  8.     @Override
  9.     protected Sheep clone() {
  10.         Sheep sheep = new Sheep();
  11.         try {
  12.             sheep = (Sheep) super.clone();
  13.             infos = infos.clone();
  14.         } catch (CloneNotSupportedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         return sheep;
  18.     }
  19. }

上述类中成员变量包含引用数据类型（数组），直接手动赋值即可。
方式二，对象序列化（推荐）

  1. public class Sheep implements Cloneable,Serializable{
  2.     private String name;
  3.     private Integer age;
  4.     private Integer[] infos;
  5.     public Sheep deepClone() {
  6.         Sheep copy = null;
  7.         ByteArrayOutputStream bos = null;
  8.         ObjectOutputStream oos = null;
  9.         ByteArrayInputStream bis = null;
  10.         ObjectInputStream ois = null;
  11.         try {
  12.             //序列化
  13.             bos = new ByteArrayOutputStream();
  14.             oos = new ObjectOutputStream(bos);
  15.             oos.writeObject(this);
  16.             //反序列化
  17.             bis = new ByteArrayInputStream(bos.toByteArray());
  18.             ois = new ObjectInputStream(bis);
  19.             copy = (Sheep) ois.readObject();
  20.         } catch (IOException | ClassNotFoundException e) {
  21.             e.printStackTrace();
  22.         } finally {
  23.             try {
  24.                 bos.close();
  25.                 oos.close();
  26.                 bis.close();
  27.                 ois.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.         return copy;
  33.     }
  34. }

这里要先在类中实现Serializable接口，然后才能实现序列化。
注意事项：
1、创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
2、不用重新初始化对象，而是动态的获得对象运行时的状态
3、如果原始对象发生变化（增加或减少属性），其他克隆对象也会发生相应的变化，无需修改代码
4、在实现深拷贝的时候可能需要比较复杂的代码
5、缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则。