创建型模式——原型模式（Prototype Pattern）

原型模式（Prototype Pattern）

使用

java中的使用（两种方式）

java中原生支持该模式，即使用克隆实现该模式

实现Cloneable接口

实现Cloneable接口并重写Object类中的clone()方法

示例：

public class CloneDemo implements Cloneable {private Param paramA;public CloneDemo(Param paramA) {this.paramA = paramA;}public Param getParamA() {return paramA;}//此处简单重写便可实现克隆@Overridepublic CloneDemo clone() {CloneDemo newInstance;try {newInstance = (CloneDemo) super.clone();} catch (CloneNotSupportedException e) {throw new AssertionError();}
//      newInstance.paramA = param.clone;//解开此处代码即为深度克隆return newInstance;}public static void main(String[] args) {CloneDemo cloneDemo = new CloneDemo(new Param("interParamOfparamA"));CloneDemo myClone = cloneDemo.clone();System.out.println("++++++===============原实例============++++++");System.out.println("实例：" + cloneDemo);//输出地址为：3ecf72fdSystem.out.println("实例参数：" + cloneDemo.getParamA());//输出地址为：4b6995dfSystem.out.println("++++++===============浅克隆============++++++");System.out.println("实例：" + myClone);//输出地址为：68837a77System.out.println("实例参数：" + myClone.getParamA());//输出地址为：4b6995df（说明两个实例同时使用的同一个参数实例！）}}class Param {private String interParam;public Param(String interParam) {this.interParam = interParam;}
}

特点：
- 效率高
- 需要定制化层层实现克隆

实现Serializable接口

实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

示例：

import java.io.*;/*** @author advancer* @Description 使用Serializable实现深克隆*/
public class DeepClone implements Serializable {private Param paramA;private transient String password;//关键字transient会将被标注的属性剔除序列化的信息public DeepClone(Param paramA) {this.paramA = paramA;}public Param getParamA() {return paramA;}public DeepClone myClone() {DeepClone newInstance = null;try {// 当前实例序列化ByteArrayOutputStream baos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(baos);oos.writeObject(this);// 当前实例反序列化ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bais);//生成实例newInstance = (DeepClone) ois.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}return newInstance;}public static void main(String[] args) {DeepClone deepClone = new DeepClone("1", new Param("2"));DeepClone myDeepClone = deepClone.myClone();System.out.println("++++++===============原实例============++++++");System.out.println("实例：" + deepClone);//输出地址为：3ecf72fdSystem.out.println("实例参数：" + deepClone.getParamA());//输出地址为：4b6995dfSystem.out.println("++++++===============深克隆============++++++");System.out.println("实例：" + myDeepClone);//输出地址为：6be46e8fSystem.out.println("实例参数：" + myDeepClone.getParamA());//输出地址为：3567135c}}class Param implements Serializable {private String interParam;public Param(String interParam) {this.interParam = interParam;}
}

工具类的实现：

因为实现Serializable接口的方式可以将其作为通用clone方法，所以可以将其抽成工具类。

public class CloneUtils {public static <T extends Serializable> T clone(T obj) throws IOException, ClassNotFoundException{// 当前实例序列化ByteArrayOutputStream baos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(baos);oos.writeObject(obj);//当前实例反序列化并生成实例ByteArrayInputStream bais = new ByteArrayInputStream(bout.toByteArray());ObjectInputStream ois = new ObjectInputStream(bin);return (T) ois.readObject();}
}

特点
- 法效率很低，需要IO
- 真正意义上的深度克隆

补充：

序列化与反序列化

序列化：把对象转换为字节序列的过程称为对象的序列化。反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

进入正题：

简介

原型模式（Prototype Pattern）通过给出一个原型对象来指明所有创建对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

意图：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

主要解决：

在运行期建立和删除原型。

何时使用：

为了避免创建一个与产品类层次平行的工厂类层次时。
当一个系统应该独立于它的产品创建，构成和表示时。
当要实例化的类是在运行时刻指定时，例如，通过动态装载。
当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

如何解决：

利用已有的一个原型对象，快速地生成和原型对象一样的实例。

关键代码：

原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。
实现克隆操作，在 JAVA 实现 Cloneable 接口，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。

UML图

取自23设计模式UML图

应用实例：

细胞分裂。
JAVA 中的 Object clone() 方法。

优点：

性能提高。
逃避构造函数的约束。
可以动态增加或减少产品类。
原型模式提供了简化的创建结构。
可以使用深克隆的方式保存对象的状态。

缺点：

必须实现 Cloneable或Serializable接口。
如果若使用Cloneable接口时，实现深克隆需要编写较为复杂的代码。
配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

使用场景：

资源优化场景。
性能和安全要求的场景。
一个对象多个修改者的场景。
原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。

注意事项：

与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。

原理：

通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
解析：
- 例
  1. 一次性使用new实例化多个对象，浪费内存
  2. 当使用时new，浪费cpu
- 解
  - 操作内存直接拷贝原始数据流复制一份
    - 不经过
      1. 类加载
      2. 实例化
      3. 初始化

扩展：

浅拷贝（向上参考简单实现Cloneable接口的方式）

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所拷贝的地址，而不复制它所引用的对象。

浅拷贝实现 Cloneable，重写。

深拷贝（向上参考具体实现Cloneable接口的方式以及实现Serializable接口的方式）

被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。