程序员Wiki

原型模式（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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

【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();
	}
}
1
2
3
4
5
6
7
8

# 四、Spring 中的应用

【1】当 scope 配置为 prototype 时，表示原型模式。

 <!-- 这里我们的 scope="prototype" 即 原型模式来创建 -->
 <bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>
1
2

【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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 五、浅拷贝

● 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新对象。
● 对于数据类型是引用类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传值，也就是只是将成员变量的引用值（内存地址）复制一份给新对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
● 浅拷贝是使用默认的 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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

【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
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 八、原型模式的注意事项和细节

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

(adsbygoogle = window.adsbygoogle || []).push({});

← 设计模式——享元模式 →