设计模式——原型模式
优质博文：IT-BLOG-CN
原型模式（Prototype Pattern）： 是用于创建重复对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。
思想： Java 中 Object 类是所有类的根类，Object 类提供了一个 clone() 方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的 Java 类必须要实现一个接口 Cloneable，该接口表示该类能够复制且具有复制的能力（原型模式）。
一、基本介绍
● 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
● 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节。
● 工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对像拷贝它们自己来实现创建，及对象的clone()。
二、类图
原理结构图说明：
1）、Prototype：原型类，声明一个克隆自己的接口 clone。
2）、ConcretePrototype：具体的原型类，实现一个克隆自己的操作。
3）、Client 让一个原型对象克隆自己，从而创建一个新的对象（相当于属性）。
三、原型模式案例分析
【1】克隆类需要实现 Cloneable 重写 clone 方法。
package com.yintong.principle.singleresponsibility;
//写一个手机的克隆类
public class ConcretePrototype implements Cloneable{
//名称
private String name;
//号码
private Long number;
//构造器
public ConcretePrototype(String name, Long number) {
super();
this.name = name;
this.number = number;
}
@Override
public String toString() {
return "ConcretePrototype [name=" + name + ", number=" + number + "]";
}
// 克隆用到的主要部分
@Override
protected Object clone() throws CloneNotSupportedException {
ConcretePrototype ConcretePrototype = null;
try {
ConcretePrototype = (ConcretePrototype) super.clone();
}catch (Exception e) {
System.out.println(e.getMessage());
}
return ConcretePrototype;
}
}
【2】客户端调用 clone 方法，实现原型模式。
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
//创建一个对象
ConcretePrototype prototype = new ConcretePrototype("华为", new Long(1568889932));
//通过原型模式完成对象的创建 克隆
ConcretePrototype p2 = (ConcretePrototype)prototype.clone();
}
}
四、Spring 中的应用
【1】当 scope 配置为 prototype 时，表示原型模式。
<bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>
【2】查看底层调用：
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// *** 创建一个代理类 ***
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
五、浅拷贝
● 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新对象。
● 对于数据类型是引用类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传值，也就是只是将成员变量的引用值（内存地址）复制一份给新对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
● 浅拷贝是使用默认的 clone() 方法来实现。
六、深拷贝
● 复制对象的所有基本数据类型的成员变量值。
● 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
● 深拷贝的实现方式有两种，第一种是重写 clone 方法来实现深拷贝，第二种是通过序列化实现深拷贝，也是推荐的一种。
七、深克隆的两种实现方法
【1】通过调用引用类型的克隆方法，实现深拷贝。缺点就是当引用类型多时，不建议采用。
public class DeepClone implements Cloneable{
//基本数据类型
private String name;
//引用数据类型
private Spare spare;
//重写clone方法，调用引用类型的克隆方法
@Override
protected Object clone() throws CloneNotSupportedException {
DeepClone deepClone = null;
deepClone = (DeepClone)super.clone();
//克隆引用数据类型
deepClone.spare = (Spare) spare.clone();
return deepClone;
}
}
【2】通过序列化的方式，实现深拷贝：也是建议使用的方法。
public class DeepClone implements Serializable{
/**
* 序列化 ID
*/
private static final long serialVersionUID = 1L;
//数据类型 略。。。。
//重写clone方法，调用引用类型的克隆方法
protected Object deepClone(){
ByteArrayOutputStream BOStream = null;
ObjectOutputStream OOSream = null;
ByteArrayInputStream BIStream = null;
ObjectInputStream OIStream =null;
try {
//序列化
BOStream = new ByteArrayOutputStream();
OOSream = new ObjectOutputStream(BOStream);
//将当前对象写入流中
OOSream.writeObject(this);
//反序列化
BIStream = new ByteArrayInputStream(BOStream.toByteArray());
OIStream = new ObjectInputStream(BIStream);
DeepClone deepClone = (DeepClone) OIStream.readObject();
return deepClone;
} catch (Exception e) {
e.printStackTrace();
return null;
}finally {
try {
BOStream.close();
OOSream.close();
BIStream.close();
OIStream.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
八、原型模式的注意事项和细节
1）、创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
2）、不用重新初始化对象，而是动态地获得对象运行时的状态。
3）、如果原始对象发生变化（增加或者减少属性），其他克隆对象也会发生变化，无需修改代码。
4）、在实现深克隆的时候可能需要比较复杂的代码。
5）、缺点：需要为每一个配置类配置一个克隆方法，这对全新的类来说不是很难,但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则。