“不好意思，我是卧底！哇哈哈哈~”额......自从写了上一篇的观察者模式，就一直沉浸在这个角色当中，无法自拨。昨晚在看《使徒行者2》，有一集说到啊炮仗哥印钞票，我去，这就是想印多少就印多少的节奏。
但是我觉得他们印钞票的方法太low了，就用那“哧咔，哧咔~”的老机器没日没夜的印，看着都着急。
这里我们可以用原型模式优化印钞票的致富之路，为什么，继续往下看......
一、原型模式
定义
用原型实例指定所有创建对象的类型，并且通过复制这个拷贝创建新的对象。
特点
1)必须存在一个现有的对象，也就是原型实例，通过原型实例创建新对象。
2)在Java中，实现Cloneable，并且因为所有的类都继承Object类，重写clone()方法来实现拷贝。
使用场景
大量的对象，并且类初始化时消耗的资源多。没人会嫌钱多的吧，除了某云。
这些钞票的信息属性基本一致，可以调整个别的属性。
印钞票的工序非常复杂，需要进行繁琐的数据处理。
UML图
从上面的UML图可以看出，原型模式涉及到的角色有如下三个：
- 客户端角色：负责创建对象的请求。
- 抽象原型角色：该角色是一个抽象类或者是接口，提供拷贝的方法。
- 具体原型角色：该角色是拷贝的对象，需要重写抽象原型的拷贝方法，实现浅拷贝或者深拷贝。
二、实战
一起来印钞票，钞票实例必须实现Cloneable接口，该接口只充当一个标记，然后重写clone方法，具体原型角色代码如下：
public class Money implements Cloneable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
@Override
protected Money clone() throws CloneNotSupportedException {
return (Money) super.clone();
}
}
Area类代码如下：
public class Area {
// 钞票单位
private String unit;
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
}
看看客户端如何实现钞票的拷贝，代码如下：
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例，100RMB的钞票
Money money = new Money(100, area);
for (int i = 1; i <= 3; i++) {
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(i * 100);
System.out.println("这张是" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit() + "的钞票");
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
}
大把大把的钞票出来了
这张是100RMB的钞票
这张是200RMB的钞票
这张是300RMB的钞票
从上面并没有看到抽象原型角色的代码，那该角色在哪？Object就是这个抽象原型角色，因为Java中所有的类都默认继承Objet，在这提供clone方法。
三、浅拷贝和深拷贝
在使用原型模式的时候，常常需要注意用的到底是浅拷贝还是深拷贝，当然这必须结合实际的项目需求。下面来了解学习这两种拷贝的用法和区别：
首先我们来看一个例子，只改变客户端代码：
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例，100RMB的钞票
Money money = new Money(100, area);
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(200);
area.setUnit("美元");
System.out.println("原型实例的面值：" + money.getFaceValue() +money.getArea().getUnit());
System.out.println("拷贝实例的面值：" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
运行结果如下：
原型实例的面值：100美元
拷贝实例的面值：200美元
浅拷贝
见鬼了，明明就把原型实例的单位改成了美元而已，拷贝实例怎么也会跟着改变的。哪里有鬼？其实是Java在搞鬼。我们用的是Object的clone方法，而该方法只拷贝按值传递的数据，比如String类型和基本类型，但对象内的数组、引用对象都不拷贝，也就是说内存中原型实例和拷贝实例指向同一个引用对象的地址，这就是浅拷贝。浅拷贝的内存变化如下图：
从上图可以看出，浅拷贝前后的两个实例对象共同指向同一个内存地址，即它们共有拥有area1实例，同时也存在着数据被修改的风险。注意，这里不可拷贝的引用对象是指可变的类成员变量。
深拷贝
同样的看例子，客户端代码如下：
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例，100RMB的钞票
Money money = new Money(100, area);
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(200);
area.setUnit("美元");
System.out.println("原型实例的面值：" + money.getFaceValue() + money.getArea().getUnit());
System.out.println("拷贝实例的面值：" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
运行结果如下：
原型实例的面值：100美元
拷贝实例的面值：200RMB
咦~这客户端代码不是跟浅拷贝的一样吗，但是运行结果却又不一样了。关键就在，实现深拷贝就需要完全的拷贝，包括引用对象，数组的拷贝。所以Area类也实现了Cloneable接口，重写了clone方法，代码如下：
public class Area implements Cloneable{
// 钞票单位
private String unit;
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
@Override
protected Area clone() throws CloneNotSupportedException {
Area cloneArea;
cloneArea = (Area) super.clone();
return cloneArea;
}
}
另外，在Money钞票类的clone方法增加拷贝Area的代码：
public class Money implements Cloneable, Serializable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
@Override
protected Money clone() throws CloneNotSupportedException {
Money cloneMoney = (Money) super.clone();
cloneMoney.area = this.area.clone(); // 增加Area的拷贝
return cloneMoney;
}
}
深拷贝的内存变化如下图：
深拷贝除了需要拷贝值传递的数据，还需要拷贝引用对象、数组，即把所有引用的对象都拷贝。需要注意的是拷贝的引用对象是否还有可变的类成员对象，如果有就继续对该成员对象进行拷贝，如此类推。所以使用深拷贝是注意分析拷贝有多深，以免影响性能。
序列化实现深拷贝
这是实现深拷贝的另一种方式，通过二进制流操作对象，从而达到深拷贝的效果。把对象写到流里的过程是序列化过程，而把对象从流中读出来的过程则叫反序列化过程。深拷贝的过程就是把对象序列化(写成二进制流)，然后再反序列化(从流里读出来)。注意，在Java中，常常可以先使对象实现Serializable接口，包括引用对象也要实现Serializable接口，不然会抛NotSerializableException。
只要修改Money，代码如下：
public class Money implements Serializable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
@Override
protected Money clone() throws CloneNotSupportedException {
Money money = null;
try {
// 调用deepClone，而不是Object的clone方法
cloneMoney = (Money) deepClone();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return cloneMoney;
}
// 通过序列化深拷贝
public Object deepClone() throws IOException, ClassNotFoundException {
//将对象写到流里
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
//从流里读回来
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
同样运行客户端代码，最后来看看结果：
原型实例的面值：100美元
拷贝实例的面值：200RMB
四、原型模式的优缺点
优点
1)提高性能。不用new对象，消耗的资源少。
缺点
1)浅拷贝时需要实现Cloneable接口，深拷贝则要特别留意是否有引用对象的拷贝。
总结
原型模式本身比较简单，重写Object的clone方法，实现浅拷贝还是深拷贝。重点在理解浅拷贝和深拷贝，这是比较细但又重要，却往往被忽略的知识点。好啦，原型模式就到这了，下一篇是
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
