[关闭]
@w1992wishes 2018-03-13T14:24:11.000000Z 字数 10443 阅读 886

设计模式--原型模式

设计模式 创建型模式

目录

本文的结构如下：

一、引言

我是一个很幼稚的人，所以经常会有很幼稚的想法，比如，有时候上着班我就在想，要是我能够影分身多好，这样，我可以让一号分身陪女朋友和家人，二号分身上班敲代码，三号分身街头卖烤串，四号分身被窝玩游戏......

我的可笑想法在当下是不现实的，但在软件开发中，却是非常务实的。设计模式中有一个模式，可以通过一个原型对象克隆出多个一模一样的对象，该模式称之为原型模式。

二、什么是原型模式

在使用原型模式时，我们需要首先创建一个原型对象，再通过复制这个原型对象来创建更多同类型的对象。一般这个原型对象的实例化很复杂，需要消耗很多的硬件资源或者数据资源，就像引言中说的“我”，是经过20多年的实例化，消耗了大量的粮食才构造成功的。

原型模式(Prototype Pattern)：当创建给定类的实例化过程很复杂或者代价很昂贵时，可以使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。

原型模式的工作原理很简单：将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程，拷贝通常是通过克隆方法实现。原型模式是一种“另类”的创建型模式，创建克隆对象的工厂就是原型类自身，工厂方法由克隆方法来实现。

三、浅克隆和深克隆

需要注意的是克隆有深克隆和浅克隆之分。

浅克隆： 在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

深克隆： 在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

四、clone()

4.1、clone()方法理解

clone()方法是Object中的一个方法，其源代码如下：

  1. protected native Object clone() throws CloneNotSupportedException;

可以发现：

JNI是Java Native Interface的 缩写。从Java 1.1开始，Java Native Interface(JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java虚拟机实现下。

4.2、Java中对象的克隆

一般需要四个步骤：

  1. 在子类中实现Cloneable接口。
  2. 为了获取对象的一份拷贝，我们可以利用Object类的clone方法。
  3. 在子类中覆盖clone方法，声明为public。
  4. 在子类的clone方法中，调用super.clone()。

Cloneable接口仅仅是一个标志接口，而且这个标志也仅仅是针对Object类中 clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出 CloneNotSupportedException 异常。

4.3、浅克隆实例

  1. public class Student implements Cloneable{
  3.     private String name;
  5.     private int age;
  7.     private Professor professor;
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  17.     public int getAge() {
  18.         return age;
  19.     }
  21.     public void setAge(int age) {
  22.         this.age = age;
  23.     }
  25.     public Professor getProfessor() {
  26.         return professor;
  27.     }
  29.     public void setProfessor(Professor professor) {
  30.         this.professor = professor;
  31.     }
  33.     @Override
  34.     public String toString() {
  35.         return "Student [name=" + name + ", age=" + age + ", professor="
  36.                 + professor + "]";
  37.     }
  39.     public Object clone() throws CloneNotSupportedException{
  40.         return super.clone();
  41.     }
  42. }
  44. public class Professor {
  46.     private String name;
  48.     private int age;
  50.     public String getName() {
  51.         return name;
  52.     }
  54.     public void setName(String name) {
  55.         this.name = name;
  56.     }
  58.     public int getAge() {
  59.         return age;
  60.     }
  62.     public void setAge(int age) {
  63.         this.age = age;
  64.     }
  66.     @Override
  67.     public String toString() {
  68.         return "Professor [name=" + name + ", age=" + age + "]";
  69.     }
  71. }
  73. public class ShadowCopy {
  75.     public static void main(String[] args) {
  76.         Professor p1 = new Professor();
  77.         p1.setName("Professor Zhang");
  78.         p1.setAge(30);
  80.         Student s1 = new Student();
  81.         s1.setName("xiao ming");
  82.         s1.setAge(18);
  83.         s1.setProfessor(p1);
  85.         System.out.println(s1);
  87.         try {
  88.             Student s2 = (Student) s1.clone();
  89.             Professor p2 = s2.getProfessor();
  90.             p2.setName("Professor Li");
  91.             p2.setAge(45);
  92.             s2.setProfessor(p2);
  93.             System.out.println("复制后的：s1 = " + s1);
  94.             System.out.println("复制后的：s2 = " + s2);
  95.         } catch (CloneNotSupportedException e) {
  96.             e.printStackTrace();
  97.         }
  99.     }
  101. }

测试结果会发现复制后打印出来的s1和s2结果是一样的，s1和s2的导师都变成了45岁的Professor Li，显然这并不是期望的结果，产生这个结果的原因lone()方法实现的是浅克隆，对象引用professor只是复制了其引用，s1和s2仍是指向相同的地址块。

4.4、深克隆实例

实现深克隆，可以在原clone()方法基础上改进一下，如下：

  1. public class Student implements Cloneable{
  3.     private String name;
  4.     private int age;
  5.     private Professor professor;
  7.     public Student(String name, int age, Professor professor){
  8.         this.name = name;
  9.         this.age = age;
  10.         this.professor = professor;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public Professor getProfessor() {
  30.         return professor;
  31.     }
  33.     public void setProfessor(Professor professor) {
  34.         this.professor = professor;
  35.     }
  37.     public Object clone(){
  38.         Student o = null;
  39.         try {
  40.             o = (Student)super.clone();
  41.         } catch (CloneNotSupportedException e) {
  42.             e.printStackTrace();
  43.         }
  44.         o.professor = (Professor)professor.clone();
  45.         return o;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Student [name=" + name + ", age=" + age + ", professor="
  51.                 + professor + "]";
  52.     }
  54. }
  56. public class Professor implements Cloneable{
  58.     private String name;
  59.     private int age;
  61.     public Professor(String name, int age){
  62.         this.name = name;
  63.         this.age = age;
  64.     }
  66.     public String getName() {
  67.         return name;
  68.     }
  70.     public void setName(String name) {
  71.         this.name = name;
  72.     }
  74.     public int getAge() {
  75.         return age;
  76.     }
  78.     public void setAge(int age) {
  79.         this.age = age;
  80.     }
  82.     @Override
  83.     public Object clone(){
  84.         Object o = name;
  85.         try {
  86.             o= super.clone();
  87.         } catch (CloneNotSupportedException e) {
  88.             e.printStackTrace();
  89.         }
  90.         return o;
  91.     }
  93.     @Override
  94.     public String toString() {
  95.         return "Professor [name=" + name + ", age=" + age + "]";
  96.     }
  98. }
  100. public class DeepClone {
  101.     public static void main(String[] args) {
  102.         Professor p=new Professor("wangwu",50);
  103.         Student s1=new Student("zhangsan",18, p);
  104.         System.out.println(s1);
  106.         Student s2=(Student)s1.clone();
  107.         s2.getProfessor().setName("maer");
  108.         s2.getProfessor().setAge(40);
  109.         System.out.println("复制后的：s1 = " + s1);
  110.         System.out.println("复制后的：s2 = " + s2);
  111.     }
  112. }

也可以利用序列化反序列化来实现深克隆:

  1. public class Student implements Serializable {
  3.     private String name;
  4.     private int age;
  5.     private Professor professor;
  7.     public Student(String name, int age, Professor professor){
  8.         this.name = name;
  9.         this.age = age;
  10.         this.professor = professor;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public Professor getProfessor() {
  30.         return professor;
  31.     }
  33.     public void setProfessor(Professor professor) {
  34.         this.professor = professor;
  35.     }
  37.     public Object deepClone() throws IOException, ClassNotFoundException {
  38.         //将对象写到流中
  39.         ByteArrayOutputStream bo=new ByteArrayOutputStream();
  40.         ObjectOutputStream oo=new ObjectOutputStream(bo);
  41.         oo.writeObject(this);
  42.         //从流中读出来
  43.         ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
  44.         ObjectInputStream oi=new ObjectInputStream(bi);
  45.         return oi.readObject();
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Student [name=" + name + ", age=" + age + ", professor="
  51.                 + professor + "]";
  52.     }
  54. }
  56. public class Professor implements Serializable {
  58.     private String name;
  59.     private int age;
  61.     public Professor(String name, int age){
  62.         this.name = name;
  63.         this.age = age;
  64.     }
  66.     public String getName() {
  67.         return name;
  68.     }
  70.     public void setName(String name) {
  71.         this.name = name;
  72.     }
  74.     public int getAge() {
  75.         return age;
  76.     }
  78.     public void setAge(int age) {
  79.         this.age = age;
  80.     }
  82.     @Override
  83.     public String toString() {
  84.         return "Professor [name=" + name + ", age=" + age + "]";
  85.     }
  87. }
  89. public class DeepClone {
  90.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  91.         Professor p=new Professor("wangwu",50);
  92.         Student s1=new Student("zhangsan",18, p);
  93.         System.out.println(s1);
  95.         Student s2=(Student)s1.deepClone();
  96.         s2.getProfessor().setName("maer");
  97.         s2.getProfessor().setAge(40);
  98.         System.out.println("复制后的：s1 = " + s1);
  99.         System.out.println("复制后的：s2 = " + s2);
  100.     }
  101. }

五、模式的结构

介绍完浅克隆和深克隆，再回到原型模式上。

原型模式的UML类图如下：

在原型模式结构图中包含如下几个角色：

六、典型代码

  1. public interface Prototype {
  2.     Prototype clone();
  3.     void setAttr(String attr);
  4. }
  6. public class ConcretePrototype implements Prototype {
  7.     private String attr; //成员属性
  9.     public void setAttr(String attr) {
  10.         this.attr = attr;
  11.     }
  13.     public String getAttr() {
  14.         return this.attr;
  15.     }
  17.     public Prototype clone() {
  18.         Prototype prototype = new ConcretePrototype(); //创建新对象
  19.         prototype.setAttr(this.attr);
  20.         return prototype;
  21.         /*Object object = null;
  22.         try {
  23.             object = super.clone();
  24.         } catch (CloneNotSupportedException exception) {
  25.             System.err.println("Not support cloneable");
  26.         }
  27.         return (Prototype) object;*/
  28.     }
  29. }

clone()方法是不能直接返回this的，相信都明白。

七、代码示例

看过仙侠小说的都知道，修炼到高境界（肯定不是练气，金丹的渣渣了），就可以炼制身外化身，这些化身都有自己的思想，可以修炼自己的功法，但却听从主体的命令，当然有时候化身也会叛变，这里就以仙人化身为例：

  1. public class Immortal implements Serializable {
  2.     private String name;
  3.     private int age;
  4.     private String magicalPower;//神通
  5.     private Wife wife;//道侣
  7.     public Immortal(String name, int age, String magicalPower) {
  8.         try {
  9.             Thread.sleep(4000);//模拟仙人修炼
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         this.name = name;
  14.         this.age = age;
  15.         this.magicalPower = magicalPower;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public void setAge(int age) {
  23.         this.age = age;
  24.     }
  26.     public void setMagicalPower(String magicalPower) {
  27.         this.magicalPower = magicalPower;
  28.     }
  30.     public void setWife(Wife wife) {
  31.         this.wife = wife;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public int getAge() {
  39.         return age;
  40.     }
  42.     public String getMagicalPower() {
  43.         return magicalPower;
  44.     }
  46.     public Wife getWife() {
  47.         return wife;
  48.     }
  50.     //使用序列化实现深克隆
  51.     public Immortal deepClone() throws IOException, ClassNotFoundException {
  52.         //将对象写入流中
  53.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  54.         ObjectOutputStream oos = new ObjectOutputStream(bos);
  55.         oos.writeObject(this);
  57.         //将对象从流中取出
  58.         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
  59.         ObjectInputStream ois = new ObjectInputStream(bis);
  60.         return (Immortal) ois.readObject();
  61.     }
  63.     public String toString() {
  64.         return "仙人 [姓名=" + name + ", 年龄=" + age + ", 神通="
  65.                 + magicalPower + ",道侣=" + wife.getName() + "]";
  66.     }
  67. }
  69. public class Wife implements Serializable{
  70.     private String name;
  71.     private int age;
  73.     public Wife(String name, int age){
  74.         this.name = name;
  75.         this.age = age;
  76.     }
  78.     public void setName(String name) {
  79.         this.name = name;
  80.     }
  82.     public void setAge(int age) {
  83.         this.age = age;
  84.     }
  86.     public String getName() {
  87.         return name;
  88.     }
  90.     public int getAge() {
  91.         return age;
  92.     }
  94.     public String toString(){
  95.         return "道侣 [姓名=" + name + ", 年龄=" + age + "]";
  96.     }
  97. }
  99. public class Client {
  100.     public static void main(String[] args) {
  101.         Wife yushiqie = new Wife("雨师妾", 3000);
  102.         Immortal immortal = new Immortal("拓拔野", 2985, "天元诀，刹那芳华");
  103.         immortal.setWife(yushiqie);
  104.         System.out.println(immortal);
  106.         try {
  107.             //故事最后拓跋陪我最爱的雨师妾归隐，但姑射仙子却没了归宿，这里假设拓跋分出一个分身
  108.             Immortal incarnation = immortal.deepClone();
  109.             Wife guyexianzi = incarnation.getWife();
  110.             System.out.println(immortal.getWife() == incarnation.getWife()); //false
  111.             guyexianzi.setName("姑射仙子");
  112.             guyexianzi.setAge(2985);
  113.             System.out.println(incarnation);
  114.             incarnation.setWife(guyexianzi);
  115.         } catch (IOException e) {
  116.             e.printStackTrace();
  117.         } catch (ClassNotFoundException e) {
  118.             e.printStackTrace();
  119.         }
  120.     }
  121. }

八、优点和缺点

8.1、优点

原型模式的主要优点如下：

8.2、缺点

原型模式的主要缺点如下：

九、适用环境

在以下情况下可以考虑使用原型模式：

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注