设计模式之原型模式

Posted 2020-08-11 李秀玉

原型模式

原型模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

这种设计模式涉及到三个角色：

1.客户(Client)角色：客户类提出创建对象的请求。

2.抽象原型(Prototype)角色：这是一个抽象角色，通常由一个Java接口或Java抽象类实现。此角色给出所有的具体原型类所需的接口。

3.具体原型（Concrete Prototype）角色：被复制的对象。此角色需要实现抽象的原型角色所要求的接口。

UML图如下：

原型模式中的复制分为两种：浅复制、深复制。

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

 

基于上述UML给出示例代码如下：

首先定义一个Prototype抽象类：

 1 public abstract class Prototype implements Serializable{
 2 
 3     private int number;
 4 
 5     private TestClass testClass;
 6 
 7     public int getNumber() {
 8         return number;
 9     }
10 
11     public void setNumber(int number) {
12         this.number = number;
13     }
14 
15     public TestClass getTestClass() {
16         return testClass;
17     }
18 
19     public void setTestClass(TestClass testClass) {
20         this.testClass = testClass;
21     }
22 
23     @Override
24     public String toString() {
25         return "[number="+ number +",testClass="+ testClass.toString() +"]";
26     }
27     //定义各个子类必须实现的接口
28     public abstract Prototype clonePrototype();
29 }

该类中引用的TestClass类如下：

 1 public class TestClass implements Cloneable,Serializable {
 2 
 3     private String attr1;
 4 
 5     private String attr2;
 6 
 7     public TestClass(String attr1, String attr2) {
 8         this.attr1 = attr1;
 9         this.attr2 = attr2;
10     }
11 
12     public String getAttr1() {
13         return attr1;
14     }
15 
16     public void setAttr1(String attr1) {
17         this.attr1 = attr1;
18     }
19 
20     public String getAttr2() {
21         return attr2;
22     }
23 
24     public void setAttr2(String attr2) {
25         this.attr2 = attr2;
26     }
27 
28     @Override
29     public String toString() {
30         return "[attr1="+ attr1 +", attr2="+ attr2 +"]";
31     }
32 
33     @Override
34     public Object clone() throws CloneNotSupportedException {
35         return (TestClass)super.clone();
36     }
37 }

下面给出三个具体的Prototype实现类：

 1 public class ConcreteProtype1 extends Prototype implements Cloneable{
 2     /**
 3      * 浅复制
 4      * @return
 5      */
 6     @Override
 7     public Prototype clonePrototype() {
 8         try {
 9             return (Prototype)super.clone();
10         } catch (CloneNotSupportedException e) {
11             e.printStackTrace();
12             return null;
13         }
14     }
15 }

 1 public class ConcreteProtype2 extends Prototype implements Cloneable{
 2 
 3     /**
 4      * 深复制
 5      * @return
 6      */
 7     @Override
 8     public Prototype clonePrototype() {
 9         try {
10             Prototype prototype = (Prototype) super.clone();
11             //此处调用testClass的clone()方法实现深复制
12             prototype.setTestClass((TestClass) super.getTestClass().clone());
13             return prototype;
14         } catch (CloneNotSupportedException e) {
15             e.printStackTrace();
16             return null;
17         }
18     }
19 }

 1 public class ConcreteProtype3 extends Prototype implements Cloneable{
 2 
 3     /**
 4      * 利用java串行化实现深复制
 5      * 能够利用java串行化实现深复制的前提是对象以及对象内部所有引用到的对象都是可串行化的
 6      * @return
 7      */
 8     @Override
 9     public Prototype clonePrototype() {
10         try {
11             /* 写入当前对象的二进制流 */
12             ByteArrayOutputStream bos = new ByteArrayOutputStream();
13             ObjectOutputStream oos = new ObjectOutputStream(bos);
14             oos.writeObject(this);
15 
16             /* 读出二进制流产生的新对象 */
17             ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
18             ObjectInputStream ois = new ObjectInputStream(bis);
19             return (Prototype)ois.readObject();
20         } catch (Exception e) {
21             e.printStackTrace();
22             return null;
23         }
24     }
25 }

给出测试类如下：

 1 public class PrototypeClient {
 2     public static void main(String[] args) {
 3 
 4         System.out.println("浅复制:");
 5 
 6         Prototype pro = new ConcreteProtype1();
 7         pro.setTestClass(new TestClass("aaa", "bbb"));
 8         Prototype pro1 = pro.clonePrototype();
 9         System.out.println("pro.testClass修改之前的值"+pro);
10         System.out.println("pro.testClass修改之前pro1的值"+pro1);
11         pro.getTestClass().setAttr1("test");
12         System.out.println("pro.testClass修改之后的值"+pro);
13         System.out.println("pro.testClass修改之后pro1的值"+pro1);
14 
15         System.out.println("深复制1");
16         Prototype pro2 = new ConcreteProtype2();
17         pro2.setTestClass(new TestClass("eee", "fff"));
18         Prototype pro3 = pro2.clonePrototype();
19         System.out.println("pro2.testClass修改之前的值"+pro2);
20         System.out.println("pro2.testClass修改之前pro3的值"+pro3);
21         pro2.getTestClass().setAttr1("test1");
22         System.out.println("pro2.testClass修改之后的值"+pro2);
23         System.out.println("pro2.testClass修改之后pro3的值"+pro3);
24 
25 
26         System.out.println("深复制2");
27         TestClass testClass = new TestClass("kkk", "jjj");
28         Prototype pro4 = new ConcreteProtype3();
29         pro4.setTestClass(testClass);
30         Prototype pro5 = pro4.clonePrototype();
31         System.out.println("pro4.testClass修改之前的值"+pro4);
32         System.out.println("pro4.testClass修改之前pro5的值"+pro5);
33         pro4.getTestClass().setAttr1("test2");
34         System.out.println("pro4.testClass修改之后的值"+pro4);
35         System.out.println("pro4.testClass修改之后pro5的值"+pro5);
36 
37     }
38 }

测试结果如下：

以上运行结果希望读者结合代码仔细体会。

总结：

1.原型模式的优点：
（1）根据客户端要求实现动态创建对象，客户端不需要知道对象的创建细节，便于代码的维护和扩展。
（2）使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。

（3） 原型模式类似于工厂模式，但它没有了工厂模式中的抽象工厂和具体工厂的层级关系，代码结构更清晰和简单。

2.原型模式的注意事项：
（1）使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不 会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为 private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的。
（2）在使用时要注意深拷贝与浅拷贝的问题。clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。