GOF23设计模式之原型模式（prototype）

一、原型模式概述

　　1.通过new产生一个对象需要非常繁琐的数据准备和访问权限，则可以使用原型模式。

　　2.就是java中的克隆技术，以某个对象为原型，复制出新的对象，显然，新的对象具备原型对象的特点。

　　3.优势：效率高（直接克隆，避免了重新执行构造函数的过程）。

　　4.克隆类似于new，但是不同于new。
　　　　new创建出来的对象属性采用默认值，克隆出来的对象属性值完全和原型对象相同，并且克隆出的新对象不会影响原型对象，然后，再修改克隆对象的值。

　　是否使用原型模式比较：

　　　　1.如果需要创建大量不费时的对象，new的对象和clone的对象效率相当

　　　　2.如果需要创建大量耗时的对象，建议使用原型模式

二、原型模式三种实现方式

　　1.浅复制：类中实现 Cloneable接口，重写clone方法

　　2.深复制：类中实现 Cloneable接口，重写clone方法时将对象一起克隆

　　3.深复制：类中实现 Serializable接口，利用反序列化实现深克隆

　　浅复制，深复制知识请点击此处

三、使用浅复制实现原型模式

　　1.使用原型模式克隆多利羊

 /**
  * 原型模式（浅克隆）
  * @author CL
  *
  */
 public class Sheep implements Cloneable {
     private String name;

     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }

     public Sheep() {
     }

     public Sheep(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

 }

　　2.测试

 public class TestSheep {

     public static void main(String[] args) throws Exception {
         Sheep s1 = new Sheep("多利");
         Sheep s2 = (Sheep) s1.clone();    //克隆对象

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName());

         s2.setName("少利");    //对克隆对象修改，不影响原对象的属性值

         System.out.println("\n--------修改克隆对象的属性值后---------\n");

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName());
     }

 }

　　控制台输出：

366712642（原型对象）-->多利
1829164700（克隆对象）-->多利

--------修改克隆对象的属性值后---------

366712642（原型对象）-->多利
1829164700（克隆对象）-->少利

四、使用深复制实现原型模式（1）

　　1.使用原型模式克隆多利羊

 import java.util.Date;

 /**
  * 原型模式（深克隆）
  * @author CL
  *
  */
 public class Sheep implements Cloneable {
     private String name;

     private Birthday birthday;

     public Object clone() throws CloneNotSupportedException {
         Sheep s = (Sheep) super.clone();    //克隆对象
         s.birthday = (Birthday) this.birthday.clone();
         return s;
     }

     public Sheep() {
     }

     public Sheep(String name, Birthday birthday) {
         this.name = name;
         this.birthday = birthday;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Birthday getBirthday() {
         return birthday;
     }

     public void setBirthday(Birthday birthday) {
         this.birthday = birthday;
     }

 }

 class Birthday implements Cloneable {
     private Date birthday;

     protected Object clone() throws CloneNotSupportedException {
         return super.clone();
     }

     public Birthday() {
     }

     public Birthday(Date birthday) {
         this.birthday = birthday;
     }

     public Date getBirthday() {
         return birthday;
     }

     public void setBirthday(Date birthday) {
         this.birthday = birthday;
     }
 }

　　2.测试

 import java.util.Date;

 /**
  * 测试原型模式（深克隆）
  * @author CL
  *
  */
 public class TestSheep {

     public static void main(String[] args) throws Exception {
         Birthday date = new Birthday(new Date(5456464L));
         Sheep s1 = new Sheep("多利", date);
         Sheep s2 = (Sheep) s1.clone();    //克隆对象

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName()+"-->"+s1.getBirthday().getBirthday());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName()+"-->"+s2.getBirthday().getBirthday());

         date.setBirthday(new Date());    //对原对象修改，克隆对象的属性值不改变

         System.out.println("\n--------修改克隆对象的属性值后---------\n");

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName()+"-->"+s1.getBirthday().getBirthday());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName()+"-->"+s2.getBirthday().getBirthday());
     }

 }

　　控制台输出：

366712642（原型对象）-->多利-->Thu Jan 01 09:30:56 CST 1970
1550089733（克隆对象）-->多利-->Thu Jan 01 09:30:56 CST 1970
366712642（原型对象）-->多利-->Fri Dec 29 17:03:26 CST 2017
1550089733（克隆对象）-->多利-->Thu Jan 01 09:30:56 CST 1970

五、使用深复制实现原型模式（2）

　　1.使用原型模式克隆多利羊

 import java.io.Serializable;
 import java.util.Date;

 /**
  * 原型模式（利用反序列化实现深克隆）
  * @author CL
  *
  */
 public class Sheep implements Serializable {
     private String name;

     private Birthday birthday;

     public Sheep() {
     }

     public Sheep(String name, Birthday birthday) {
         this.name = name;
         this.birthday = birthday;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Birthday getBirthday() {
         return birthday;
     }

     public void setBirthday(Birthday birthday) {
         this.birthday = birthday;
     }

 }

 class Birthday implements Serializable {
     private Date birthday;

     public Birthday() {
     }

     public Birthday(Date birthday) {
         this.birthday = birthday;
     }

     public Date getBirthday() {
         return birthday;
     }

     public void setBirthday(Date birthday) {
         this.birthday = birthday;
     }
 }

　　2.测试

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.Date;

 /**
  * 测试原型模式（利用反序列化实现深克隆）
  * @author CL
  *
  */
 public class TestSheep {

     public static void main(String[] args) throws Exception {
         Birthday date = new Birthday(new Date(5456464L));
         Sheep s1 = new Sheep("多利", date);

         //利用反序列化实现深克隆
         //1. 序列化
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos);
         oos.writeObject(s1);
         byte[] bytes = bos.toByteArray();

         //2. 反序列化
         ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
         ObjectInputStream ois = new ObjectInputStream(bis);
         Sheep s2 = (Sheep) ois.readObject();

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName()+"-->"+s1.getBirthday().getBirthday());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName()+"-->"+s2.getBirthday().getBirthday());

         date.setBirthday(new Date());    //对原对象修改，克隆对象的属性值不改变

         System.out.println("\n--------------------修改克隆对象的属性值后---------------------\n");

         System.out.println(s1.hashCode()+"（原型对象）-->"+s1.getName()+"-->"+s1.getBirthday().getBirthday());
         System.out.println(s2.hashCode()+"（克隆对象）-->"+s2.getName()+"-->"+s2.getBirthday().getBirthday());
     }

 }

　　控制台输出：

1442407170（原型对象）-->多利-->Thu Jan 01 09:30:56 CST 1970
1173230247（克隆对象）-->多利-->Thu Jan 01 09:30:56 CST 1970

--------------------修改克隆对象的属性值后---------------------

1442407170（原型对象）-->多利-->Fri Dec 29 17:11:21 CST 2017
1173230247（克隆对象）-->多利-->Thu Jan 01 09:30:56 CST 1970

六、原型模式常见应用场景

　　1.原型模式很少单独出现，一般是和工厂方法模式一起出现。通过clone的方法创建一个对象，然后由工厂方法提供给调用者；

　　2.Spring中的bean的创建其实就是两种：单例模式和原型模式（+工厂模式）；

　　3.………………

//对原型对象的修改