设计模式 - 原型模式

原型模式是创建型模式的一种，其特点在于通过 “复制” 一个已经存在的实例来返回新的实例，而不是新建实例。被复制的实例就是我们所称的 “原型”，这个原型是可定制的。

类图

代码实现

用于测试的 JavaBean：

package com.huey.pattern.prototype;

import java.io.Serializable;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@ToString
@NoArgsConstructor
@AllArgsConstructor
public class TestBean implements Serializable {

/**
*
*/
private static final long serialVersionUID = -2351683706932774662L;

@Getter @Setter
private String testValue;

}

抽象原型：

package com.huey.pattern.prototype;

/**
* the abstract prototype
* @author  huey
* @version 1.0
* @created 2015-11-27
*/
public abstract class Prototype implements Cloneable {

public Prototype() {
System.out.println("Prototype is constructed.");
}

@Override
protected Prototype clone() {
try {
return (Prototype) super.clone();
} catch (Exception e) {
return null;
}
}

}

具体原型：

package com.huey.pattern.prototype;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
* the concrete prototype
* @author  huey
* @version 1.0
* @created 2015-11-27
*/
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class ShallowCopyBean extends Prototype {

@Getter @Setter
private Integer primitiveValue;
@Getter @Setter
private TestBean customValue;

}

单元测试：

package com.huey.pattern.prototype;

public class ShallowCopyBeanTest {

public static void main(String[] args) {
Prototype cloneableBean = new ShallowCopyBean(10, new TestBean("AAA"));
System.out.println("cloneableBean: " + cloneableBean);

ShallowCopyBean clonedBean = (ShallowCopyBean) cloneableBean.clone();
clonedBean.setPrimitiveValue(100);
clonedBean.getCustomValue().setTestValue("BBB");
System.out.println("cloneableBean: " + cloneableBean);
System.out.println("clonedBean: " + clonedBean);
}

}

结果输出：

Prototype is constructed.
cloneableBean: ShallowCopyBean(primitiveValue=10, customValue=TestBean(testValue=AAA))
cloneableBean: ShallowCopyBean(primitiveValue=10, customValue=TestBean(testValue=BBB))
clonedBean: ShallowCopyBean(primitiveValue=100, customValue=TestBean(testValue=BBB))

从输出可以看到，原型只被构造一次。但是这里需要注意当 clonedBean 的引用对象 customVaule 的内容发生改变时，cloneableBean 的 customVaule 也跟着改变。这就是深拷贝与浅拷贝的问题，Java 中，Object 类的 clone 方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

深拷贝

实现深拷贝可以在重写 clone 方法中，对数组、容器对象、引用对象等自己进行拷贝。

还可以使用一个技巧，就是利用序列化的机制来实现，通过将对象序列化到输出流中，然后将其读回，这样产生的新对象是对现有对象的一个深拷贝。

代码实现

可序列化的抽象原型：

package com.huey.pattern.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
* the abstract prototype
* @author  huey
* @version 1.0
* @created 2015-11-27
*/
public abstract class SerialCloneable implements Serializable, Cloneable {

/**
*
*/
private static final long serialVersionUID = -2477239830471073680L;

@Override
protected Object clone() {
try {
/**
* serialize the object to the output stream
*/
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream output = new ObjectOutputStream(bout);
output.writeObject(this);
output.close();

/**
* deserialize the object from the input stream
*/
ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
ObjectInputStream input = new ObjectInputStream(bin);
Object result = input.readObject();
input.close();

return result;
} catch (Exception e) {
return null;
}
}
}

具体原型：

package com.huey.pattern.prototype;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
* the concrete prototype
* @author  huey
* @version 1.0
* @created 2015-11-27
*/
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class DeepCopyBean extends SerialCloneable {

/**
*
*/
private static final long serialVersionUID = -959424582381713341L;

@Getter @Setter
private Integer primitiveValue;
@Getter @Setter
private TestBean customValue;

}

单元测试：

package com.huey.pattern.prototype;

public class DeepCopyBeanTest {

public static void main(String[] args) {

SerialCloneable cloneableBean = new DeepCopyBean(10, new TestBean("AAA"));
System.out.println("cloneableBean: " + cloneableBean);

DeepCopyBean clonedBean = (DeepCopyBean) cloneableBean.clone();
clonedBean.setPrimitiveValue(100);
clonedBean.getCustomValue().setTestValue("BBB");
System.out.println("cloneableBean: " + cloneableBean);
System.out.println("clonedBean: " + clonedBean);
}

}

结果输出：

cloneableBean: DeepCopyBean(primitiveValue=10, customValue=TestBean(testValue=AAA))
cloneableBean: DeepCopyBean(primitiveValue=10, customValue=TestBean(testValue=AAA))
clonedBean: DeepCopyBean(primitiveValue=100, customValue=TestBean(testValue=BBB))

从输出可以看到，clonedBean 的引用对象 customVaule 的内容发生改变时，不会影响到 cloneableBean 的 customVaule。

原型模式的适用场合

1) 产生对象过程比较复杂，初始化需要许多资源时；

2) 希望框架原型和产生对象分开时；

3) 同一个对象可能会供其他调用者使用访问时。