Design Patterns 之原型模式

悠悠 2022-12-25 03:51 268阅读 0赞

原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。
watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70
原型模式的优点：

  • Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
  • 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的克隆分为浅克隆和深克隆。

  • 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
  • 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

下面来看一个具体的例子：

创建一个 Horse 类对象，每调用一次 run 方法。该对象的 distance 属性都会递增 10 。

浅克隆

使用 Java 的 Object 的 浅克隆 方式：
watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk0MTM2NA_size_16_color_FFFFFF_t_70 1

Person 类必须先实现 Cloneable 接口。

  1. package com.lsu.prototype.homework;
  3. /** * 抽象原型 * * @author wang suo * @version 1.0 * @date 2020/11/30 0030 13:22 */
  4. public interface Prototype { 
  5.     /** * 克隆自己 * * @return 返回 obj */
  6.     public Object cloneSelf();
  7. }
  9. package com.lsu.prototype.homework;
  12. /** * 人 * * @Author wang suo * @Date 2020/11/30 0030 14:22 * @Version 1.0 */
  13. public class Person implements Cloneable, Prototype { 
  14.     /** * 坐骑 */
  15.     private Horse mount;
  17.     Person(Horse horse) { 
  18.         super();
  19.         this.mount = horse;
  20.     }
  22.     @Override
  23.     public Object cloneSelf() { 
  24.         Object obj = null;
  25.         try { 
  26.             obj = clone();
  27.         } catch (CloneNotSupportedException e) { 
  28.             e.printStackTrace();
  29.         }
  30.         return obj;
  31.     }
  33.     /** * 人跑路 */
  34.     void run() { 
  35.         // 使用坐骑跑路
  36.         mount.run();
  37.         // 显示路程
  38.         mount.show();
  39.     }
  40. }
  42. package com.lsu.prototype.homework;
  44. import java.io.*;
  46. /** * 马 * * @Author wang suo * @Date 2020/11/30 0030 13:13 * @Version 1.0 */
  47. class Horse implements Serializable { 
  48.     private int distance = 0;
  50.     /** * 每次距离+10 */
  51.     void run() { 
  52.         this.distance += 10;
  53.     }
  55.     /** * 显示路程 */
  56.     void show() { 
  57.         System.out.println("distance = " + this.distance);
  58.     }
  59. }
  61. package com.lsu.prototype.homework;
  63. /** * 测试类 * * @Author wang suo * @Date 2020/11/30 0030 13:12 * @Version 1.0 */
  64. public class Test { 
  65.     public static void main(String[] args) { 
  66.         Horse horse = new Horse();
  67.         // 第一个骑士
  68.         Person p1 = new Person(horse);
  69.         // 第二个骑士
  70.         Person p2 = (Person) p1.cloneSelf();
  71.         p1.run();
  72.         p2.run();
  73.     }
  74. }

如上代码，我们克隆了一匹马 h2 我们想要的结果是这两头马各走了 10 米，但是结果却将这两者相加了，明明是两头马跑的距离却被算成了一头马跑的距离。

  1. distance = 10
  2. distance = 20
  4. Process finished with exit code 0

这就是浅克隆，如果调用 clone 方法的当前对象拥有的成员变量是一个对象，那么 clone 方法仅仅是复制了当前对象所拥有的对象的 引用 ，并没有复制这个对象所拥有的变量，所以还是同一个对象。

深度克隆

修改 Person 继承自 Serializable 接口。

  1. package com.lsu.prototype.homework;
  3. /** * 抽象原型 * * @author wang suo * @version 1.0 * @date 2020/11/30 0030 13:22 */
  4. public interface Prototype { 
  5.     /** * 克隆自己 * * @return 返回 obj */
  6.     Object cloneSelf();
  7. }
  9. package com.lsu.prototype.homework;
  11. import java.io.*;
  13. /** * 人 * * @Author wang suo * @Date 2020/11/30 0030 14:22 * @Version 1.0 */
  14. public class Person implements Serializable, Prototype { 
  15.     /** * 坐骑 */
  16.     private Horse mount;
  18.     Person(Horse horse) { 
  19.         super();
  20.         this.mount = horse;
  21.     }
  23.     @Override
  24.     public Object cloneSelf() { 
  25.         Object obj = null;
  26.         try { 
  27.             //obj = clone();
  28.             // 使用深克隆
  29.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  30.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  31.             objectOutputStream.writeObject(this);
  32.             ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
  33.             ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  34.             obj = objectInputStream.readObject();
  35.         } catch (IOException | ClassNotFoundException e) { 
  36.             e.printStackTrace();
  37.         }
  38.         return obj;
  39.     }
  41.     /** * 人跑路 */
  42.     void run() { 
  43.         // 使用坐骑跑路
  44.         mount.run();
  45.         // 显示路程
  46.         mount.show();
  47.     }
  48. }
  50. package com.lsu.prototype.homework;
  52. import java.io.*;
  54. /** * 马 * * @Author wang suo * @Date 2020/11/30 0030 13:13 * @Version 1.0 */
  55. class Horse implements Serializable { 
  56.     private int distance = 0;
  58.     /** * 每次距离+10 */
  59.     void run() { 
  60.         this.distance += 10;
  61.     }
  63.     /** * 显示路程 */
  64.     void show() { 
  65.         System.out.println("distance = " + this.distance);
  66.     }
  67. }
  69. package com.lsu.prototype.homework;
  71. /** * 测试类 * * @Author wang suo * @Date 2020/11/30 0030 13:12 * @Version 1.0 */
  72. public class Test { 
  73.     public static void main(String[] args) { 
  74.         Horse horse = new Horse();
  75.         // 第一个骑士
  76.         Person p1 = new Person(horse);
  77.         // 第二个骑士
  78.         Person p2 = (Person) p1.cloneSelf();
  79.         p1.run();
  80.         p2.run();
  81.     }
  82. }

测试可以实现深度复制，即包含的对象也不是同一个了。

  1. distance = 10
  2. distance = 10
  4. Process finished with exit code 0

如果我们使用序列化技术将对象保存到本地，然后在想用的时候，再拿出来使用应该如何实现呢？

就像玩游戏的存档一样，玩了几关之后存档，之后再回来继续玩。

修改 Person 的代码如下即可：

  1. package com.lsu.prototype.homework;
  3. import java.io.*;
  5. /** * 人 * * @Author wang suo * @Date 2020/11/30 0030 14:22 * @Version 1.0 */
  6. public class Person implements Serializable, Prototype { 
  7.     /** * 坐骑 */
  8.     private Horse mount;
  10.     Person(Horse horse) { 
  11.         super();
  12.         this.mount = horse;
  13.     }
  15.     public Horse getMount() { 
  16.         return mount;
  17.     }
  19.     @Override
  20.     public Object cloneSelf() { 
  21.         Object obj = null;
  22.         try { 
  23.             //obj = clone();
  24.             // 使用深克隆
  25.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  26.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  27.             objectOutputStream.writeObject(this);
  28.             ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
  29.             ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  30.             obj = objectInputStream.readObject();
  31.         } catch (IOException | ClassNotFoundException e) { 
  32.             e.printStackTrace();
  33.         }
  34.         return obj;
  35.     }
  37.     /** * 文件存档 */
  38.     void archive(String path, String fileName) { 
  39.         File file = new File(path, fileName);
  40.         boolean b = true;
  41.         ObjectOutputStream objectOutputStream = null;
  42.         try { 
  43.             if (!file.exists()) { 
  44.                 b = file.createNewFile();
  45.             }
  46.         } catch (IOException e) { 
  47.             e.printStackTrace();
  48.         }
  49.         if (b && file.exists()) { 
  50.             // 写入到文件中
  51.             try { 
  52.                 objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
  53.                 objectOutputStream.writeObject(this);
  54.                 System.out.println("文件序列化成功，本地地址："+ path + "文件名：" + fileName);
  55.             } catch (IOException e) { 
  56.                 e.printStackTrace();
  57.             } finally { 
  58.                 // 关闭输出流
  59.                 try { 
  60.                     if (objectOutputStream != null) { 
  61.                         objectOutputStream.close();
  62.                     }
  63.                 } catch (IOException e) { 
  64.                     e.printStackTrace();
  65.                 }
  66.             }
  67.         }
  68.     }
  70.     /** * 读取存档 */
  71.     Person readArchive(String path, String fileName) { 
  72.         File file = new File(path, fileName);
  73.         ObjectInputStream objectInputStream = null;
  74.         Person obj = null;
  75.         // 写入
  76.         try { 
  77.             objectInputStream = new ObjectInputStream(new FileInputStream(file));
  78.             obj = (Person) objectInputStream.readObject();
  79.             System.out.println("文件读取成功");
  80.         } catch (IOException | ClassNotFoundException e) { 
  81.             e.printStackTrace();
  82.         } finally { 
  83.             // 关闭输入流
  84.             try { 
  85.                 if (objectInputStream != null) { 
  86.                     objectInputStream.close();
  87.                 }
  88.             } catch (IOException e) { 
  89.                 e.printStackTrace();
  90.             }
  91.         }
  92.         return obj;
  93.     }
  95.     /** * 人跑路 */
  96.     void run() { 
  97.         // 使用坐骑跑路
  98.         mount.run();
  99.         // 显示路程
  100.         mount.show();
  101.     }
  102. }
  104. public class Test { 
  105.     public static void main(String[] args) { 
  106.         Horse horse = new Horse();
  107.         // 第一个骑士
  108.         Person p1 = new Person(horse);
  109.         // 第二个骑士
  110.         Person p2 = (Person) p1.cloneSelf();
  111.         p1.run();
  112.         p2.run();
  113.         // fileName = "archive.txt"; path = "D:"
  115.         /* 保存到本地 */
  116.         p2.archive("D:", "archive.txt");
  117.         System.out.println("---------------------------");
  118.         System.out.println("---p2 存档成功! 现在距离--" + p2.getMount().getDistance() + "米");
  119.         System.out.println("---------------------------");
  121.         /* 实现现场恢复 */
  122.         Person p3 = p2.readArchive("D:", "archive.txt");
  123.         System.out.println("---------------------------");
  124.         System.out.println("---读取存档成功! 现在距离--" + p3.getMount().getDistance() + "米");
  125.         System.out.println("---------------------------");
  126.         p3.run();
  127.     }
  128. }

这就是原型模式最佳实践。

发表评论

表情：
评论列表 （有 0 条评论，268人围观）

还没有评论，来说两句吧...

相关阅读

    相关 原型模式（Prototype Pattern）

    一、模式动机 原型模式（Prototype Pattern）结构较为简单，它是一种特殊的创建型模式，当需要创建大量相同或者相似对象时，可以通过对一个已有对象的复制获取更多

    亦凉亦凉/ 0 赞/ 171 阅读

    相关 Prototype pattern(原型模式)

    原型模式是一种创建型模式，来看下定义和使用场景： 定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象（通过克隆方法，不调用构造函数）； 使用场景：创建对象消

    朱雀朱雀/ 0 赞/ 313 阅读

    相关 Design Patterns 之原型模式

    原型（`Prototype`）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这

    悠悠悠悠/ 0 赞/ 269 阅读

    相关 Design Patterns 之工厂模式

    现实生活中，原始社会自给自足（没有工厂），农耕社会小作坊（简单工厂，民间酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。 我们的项目代码同

    ╰+攻爆jí腚メ╰+攻爆jí腚メ/ 0 赞/ 274 阅读

    相关 Design Patterns 之命令模式

    一、前言 在许多设计中，经常会出现一个对象直接请求另一个对象调用其方法以达到某种目的的行为，这里的两个类之间就会出现紧耦合。这很不好，所以我们应该将 方法的请求者 和 方

    电玩女神电玩女神/ 0 赞/ 297 阅读