设计模式——原型模式

一. 概述

原型模式（Prototype） ，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

相信大家都都听过Java中的克隆（clone()），所谓的原型模式其实就是克隆，以某个对象为原型，复制出新的对象。

二. 代码实现

在概述中提到，原型模式其实就是Java中的克隆，在Java中实现克隆可以通过实现 Cloneable接口，并重写clone()方法来实现。可以发现Cloneable接口中并没有定义任何方法，clone()方法定义在Object中，其实Cloneable和Serializable一样都是标记型接口，内部没有方法和属性，实现Cloneable接口表示该对象能被克隆，能使用Object.clone()方法。如果没有实现Cloneable的类调用Object.clone()方法就会抛出CloneNotSupportedException。

Prototype

实现Cloneable，并重写clone()方法，Prototype有两个属性，一个是基本类型的，一个是对象引用，之后来看clone的结果是怎么样的。

package io.github.brightloong.design.prototype;  /**  * Created by BrightLoong on 2018/7/8.  */ public class Prototype implements Cloneable {     //基本类型的属性     private String attribute;      //对象属性，引用     private Attribute attributeObject;      public Prototype(String attribute, Attribute attributeObject) {         this.attribute = attribute;         this.attributeObject = attributeObject;     }      public String getAttribute() {         return attribute;     }      public void setAttribute(String attribute) {         this.attribute = attribute;     }      public Attribute getAttributeObject() {         return attributeObject;     }      public void setAttributeObject(Attribute attributeObject) {         this.attributeObject = attributeObject;     }      /**      * 重写clone方法，这里实现的是浅拷贝，如果要进行深拷贝需要自己实现。      * @return      * @throws CloneNotSupportedException      */     @Override     public Object clone() throws CloneNotSupportedException {         return super.clone();     } }

Attribute

package io.github.brightloong.design.prototype;  /**  * Created by BrightLoong on 2018/7/8.  */ public class Attribute {     public String name;      public Attribute(String name) {         this.name = name;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     } }

客户端调用和输出

package io.github.brightloong.design.prototype;  /**  * Created by BrightLoong on 2018/7/8.  */ public class Client {     public static void main(String[] args) throws CloneNotSupportedException {         Attribute attributeObject = new Attribute("BrightLoong");         Prototype prototype = new Prototype("属性", attributeObject);         Prototype copy = (Prototype) prototype.clone();          System.out.println(copy.getAttribute() + "======" + copy.getAttributeObject().getName());          //克隆后，原型中的对象引用的还是同一个，所以输出true         System.out.println(attributeObject == copy.getAttributeObject());     } }

输出如下：

属性======BrightLoong true

可以看到结果符合预期，进行了clone，但是发现Attribute属性试用==比较返回的是true，说明引用的是同一个Attribute，两个Prototype对象引用了同一个Attribute对象，这就是所谓的浅拷贝。

三. 浅拷贝和深拷贝

Object的clone()方法，如果属性是基本类型，对该属性的值进行复制，如果属性是引用类型，则复制引用而不是复制引用的对象。

浅拷贝：浅拷贝是指拷贝对象时，拷贝的对象的所有基本类型属性的值都与原来的对象的值相同，而引用属性仍然指向原来对象中的引用属性。

深拷贝：深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。

四. 深拷贝代码实现

如何实现深拷贝，当然最简单粗暴的方法就是对引用的对象实现克隆，如果引用的对象中还有对象，那么对引用的对象中的对象的实现克隆，依次类推。

这里使用另外一种方法，通过序列化(Serialization) 类实现深克隆。通过将对象写到流中，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中，再从流里将其读出来，可以实现深克隆。 对象序列化需要实现Serializable 接口。

下面是修改后的代码：

Prototype

同时实现Cloneable, Serializable ，并重写clone()方法。

package io.github.brightloong.design.prototype;  import java.io.*;  /**  * Created by BrightLoong on 2018/7/8.  */ public class Prototype implements Cloneable, Serializable {     //基本类型的属性     private String attribute;      //对象属性，引用     private Attribute attributeObject;      public Prototype(String attribute, Attribute attributeObject) {         this.attribute = attribute;         this.attributeObject = attributeObject;     }      public String getAttribute() {         return attribute;     }      public void setAttribute(String attribute) {         this.attribute = attribute;     }      public Attribute getAttributeObject() {         return attributeObject;     }      public void setAttributeObject(Attribute attributeObject) {         this.attributeObject = attributeObject;     }      /**      * 重写clone方法，这里实现的是浅拷贝，如果要进行深拷贝需要自己实现。      * @return      * @throws CloneNotSupportedException      */     @Override     public Object clone() throws CloneNotSupportedException {         //将对象写入流中          ByteArrayOutputStream bao=new  ByteArrayOutputStream();         ObjectOutputStream oos = null;         ObjectInputStream ois = null;         Object copy = null;         try {             //将对象写入流中             oos = new ObjectOutputStream(bao);             oos.writeObject(this);             //将对象从流中取出             ByteArrayInputStream bis=new  ByteArrayInputStream(bao.toByteArray());             ois=new  ObjectInputStream(bis);             copy =  ois.readObject();         } catch (Exception e) {             e.printStackTrace();             if (oos != null) {                 try {                     oos.close();                 } catch (IOException e1) {                     e1.printStackTrace();                 }             }             if (ois != null) {                 try {                     ois.close();                 } catch (IOException e1) {                     e1.printStackTrace();                 }             }         }         return copy;     } }

Attribute

Attribute同样实现Serializable。

package io.github.brightloong.design.prototype;  import java.io.Serializable;  /**  * Created by BrightLoong on 2018/7/8.  */ public class Attribute implements Serializable{     public String name;      public Attribute(String name) {         this.name = name;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     } }

输出

还是使用原来的Client，输出如下，可以看到Attribute属性不再是同一个了，使用==比较返回了false。

属性======BrightLoong false

五. 总结

使用场景

• 如果某个对象new的过程中很耗时（类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等 ），则可以考虑使用原型模式 。
• 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时。
• 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用 。

优点

• 提高了效率，逃避了类的构造方法（对象拷贝时，类的构造函数是不会被执行的 ）。
• 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程 。

缺点

• 在实现深克隆的时候，使用的对象可能是原来已经存在的，并且没有实现Serializable，这个时候只能自己去一层一层的克隆，编写较为复杂的代码。

其他

在很多工具类中已经实现了属性拷贝，并不用我们自己去实现比如apache.commons.beanutils 中的BeanUtils.copyProperties(obj1,obj2) 和PropertyUtils .copyProperties(obj1,obj2)。spring中也有类似的实现。