【GOF23设计模式】原型模式

来源：http://www.bjsxt.com/ 
一、【GOF23设计模式】_原型模式、prototype、浅复制、深复制、Cloneable接口 

浅复制

 package com.test.prototype;

 import java.util.Date;

 /**
  * 浅复制
  */
 public class Sheep implements Cloneable{//Cloneable为标记接口
     private String sname;
     private Date birthday;

     @Override
     protected Object clone() throws CloneNotSupportedException {
         Object obj = super.clone();//直接调用object对象的clone()方法
         return obj;
     }

     public Sheep() {
     }

     public Sheep(String sname, Date birthday) {
         super();
         this.sname = sname;
         this.birthday = birthday;
     }

     public String getSname() {
         return sname;
     }

     public void setSname(String sname) {
         this.sname = sname;
     }

     public Date getBirthday() {
         return birthday;
     }

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

 package com.test.prototype;

 import java.util.Date;
 /**
  * 测试原型模式(浅复制)
  */
 public class Client {
     public static void main(String[] args) throws Exception {
         Date date = new Date(3333332323L);
         Sheep s1 = new Sheep("少利", date);
         Sheep s2 = (Sheep) s1.clone();

         System.out.println(s1);
         System.out.println(s1.getSname());
         System.out.println(s1.getBirthday());
         date.setTime(332324355555555L);//浅复制：s1和s2指向同一date对象的地址，一改全改
         System.out.println(s1.getBirthday());//s1.getBirthday() == s2.getBirthday()

         s2.setSname("多利");
         System.out.println(s2);
         System.out.println(s2.getSname());
         System.out.println(s2.getBirthday());
     }
 }

控制台输出：s1修改时间后，s2的也跟着改(Fri Dec 10 00:59:15 CST 12500)

com.test.prototype.Sheep@1db9742
少利
Sun Feb 08 21:55:32 CST 1970
Fri Dec 10 00:59:15 CST 12500
com.test.prototype.Sheep@647e05
多利
Fri Dec 10 00:59:15 CST 12500

深复制

 package com.test.prototype;

 import java.util.Date;

 /**
  * 深复制
  */
 public class Sheep2 implements Cloneable{//Cloneable为标记接口
     private String sname;
     private Date birthday;

     @Override
     protected Object clone() throws CloneNotSupportedException {
         Object obj = super.clone();//直接调用object对象的clone()方法

         //添加如下代码实现深复制(Deep Clone)
         Sheep2 s = (Sheep2) obj;
         s.birthday = (Date) this.birthday.clone();//属性克隆！

         return obj;
     }

     public Sheep2() {
     }

     public Sheep2(String sname, Date birthday) {
         super();
         this.sname = sname;
         this.birthday = birthday;
     }

     public String getSname() {
         return sname;
     }

     public void setSname(String sname) {
         this.sname = sname;
     }

     public Date getBirthday() {
         return birthday;
     }

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

 package com.test.prototype;

 import java.util.Date;
 /**
  * 测试原型模式(深复制)
  */
 public class Client2 {
     public static void main(String[] args) throws Exception {
         Date date = new Date(3333332323L);
         Sheep2 s1 = new Sheep2("少利", date);
         Sheep2 s2 = (Sheep2) s1.clone();

         System.out.println(s1);
         System.out.println(s1.getSname());
         System.out.println(s1.getBirthday());
         date.setTime(332324355555555L);//浅复制：s1和s2指向同一date对象的地址，一改全改
         System.out.println(s1.getBirthday());//s1.getBirthday() == s2.getBirthday()

         s2.setSname("多利");
         System.out.println(s2);
         System.out.println(s2.getSname());
         System.out.println(s2.getBirthday());
     }
 }

控制台输出：s1修改时间后，s2还是最初的(Sun Feb 08 21:55:32 CST 1970)

com.test.prototype.Sheep2@1db9742
少利
Sun Feb 08 21:55:32 CST 1970
Fri Dec 10 00:59:15 CST 12500
com.test.prototype.Sheep2@647e05
多利
Sun Feb 08 21:55:32 CST 1970

二、【GOF23设计模式】_原型模式、反序列化实现深复制、效率对比、创建型模式总结 
利用序列化和反序列化技术实现深复制

 package com.test.prototype;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.Date;
 /**
  * 原型模式(使用序列化和反序列化的方式实现深复制)
  */
 public class Client3 {
     public static void main(String[] args) throws Exception {
         Date date = new Date(3333332323L);
         Sheep s1 = new Sheep("少利", date);

         System.out.println(s1);
         System.out.println(s1.getSname());
         System.out.println(s1.getBirthday());

 //      Sheep s2 = (Sheep) s1.clone();
         //使用序列化和反序列化实现深复制
         //序列化
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream    oos = new ObjectOutputStream(bos);
         oos.writeObject(s1);
         byte[] bytes = bos.toByteArray();

         //反序列化
         ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
         ObjectInputStream    ois = new ObjectInputStream(bis);

         Sheep s2 = (Sheep) ois.readObject();//深复制的对象

         System.out.println("修改原型对象的属性值");
         date.setTime(332324355555555L);
         System.out.println(s1.getBirthday());

         s2.setSname("多利");
         System.out.println(s2);
         System.out.println(s2.getSname());
         System.out.println(s2.getBirthday());
     }
 }

短时间大量创建对象时，原型模式和普通new方式效率测试：

 package com.test.prototype;
 /**
  * 测试普通new方式创建对象和clone方式创建对象的效率差异！
  * 如果需要短时间创建大量对象，并且new的过程比较耗时，则可以考虑使用原型模式！
  */
 public class Client4 {

     public static void testNew(int size){
         long start = System.currentTimeMillis();
         for (int i = 0; i < size; i++) {
             Laptop t = new Laptop();
         }
         long end = System.currentTimeMillis();
         System.out.println("new的方式创建耗时：" + (end - start));
     }

     public static void testClone(int size) throws CloneNotSupportedException{
         long start = System.currentTimeMillis();
         Laptop t = new Laptop();
         for (int i = 0; i < size; i++) {
             Laptop temp = (Laptop) t.clone();
         }
         long end = System.currentTimeMillis();
         System.out.println("clone的方式创建耗时：" + (end - start));
     }

     public static void main(String[] args) throws Exception {
         testNew(1000);
         testClone(1000);
     }
 }

 class Laptop implements Cloneable{//笔记本电脑
     public Laptop(){
         try{
             Thread.sleep(10);//模拟创建对象耗时的过程！
         }catch(InterruptedException e){
             e.printStackTrace();
         }
     }

     @Override
     protected Object clone() throws CloneNotSupportedException {
         Object obj = super.clone();//直接调用object对象的clone()方法
         return obj;
     }
 }

控制台输出：

new的方式创建耗时：10168
clone的方式创建耗时：10

开发中的应用场景： 
原型模式很少单独出现，一般和工厂模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。 
spring中bean的创建实际就是两种：单例模式和原型模式（原型模式需要和工厂模式搭配起来）。

创建型模式的总结：