设计模式之原型模式_"scope=\"prototype\"属于原型模式吗?"

设计模式之原型模式

一、问题引入

克隆羊问题：

​ 现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊 属性完全相同的 10只羊。

二、传统形式解决克隆羊问题

1、类图分析

2、代码实现

Sheep类

``

public class Sheep {
   
   private String name;
   private int age;
   private String color;
   
   public Sheep(String name, int age, String color) {
      super();
      this.name = name;
      this.age = age;
      this.color = color;
   }
   //getter and setter 方法
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String getColor() {
      return color;
   }
   public void setColor(String color) {
      this.color = color;
   }
   @Override
   public String toString() {
      return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
   }
   
   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

Client 类

``

public class Client {

   public static void main(String[] args) {
      //传统的方法
      Sheep sheep = new Sheep("tom", 1, "白色");

      Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
      Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
      Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
      Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
      //....

      System.out.println(sheep);
      System.out.println(sheep2);
      System.out.println(sheep3);
      System.out.println(sheep4);
      System.out.println(sheep5);
      //...
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3、传统方式的优缺点

1. 易于理解，容易操作
2. 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
3. 总是需要初始化对象，而不是动态的活动对象运行时的状态，灵活性差

改进思路

Java 中 Object 类是所有类的根类，Object 类提供了一个 clone()方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的Java 类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力 =>原型模式

三、原型模式

1、基本介绍

1. 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象；
2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建
3. 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()
4. 形象理解：孙悟空拔出自己的猴毛，猴毛变成其他孙悟空

2、原型模式原理结构图

原理结构图说明

首先，说一下Prototype，Prototype是一个原型类，声明一个克隆自己的接口；

其次， ConcretePrototype是具体的原型类, 实现一个克隆自己的操作；

最后， Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样）

3、代码改进

首先在Sheep.java中新增属性

private String address = "蒙古羊";

并重写toString方法

``

@Override
public String toString() {
   return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
}
1
2
3
4

然后，Sheep类实现Cloneable接口，并重写clone方法

``

//克隆该实例，使用默认的clone方法来完成
@Override
protected Object clone() {

   Sheep sheep = null;
   try {
      sheep = (Sheep) super.clone();//super.clone()返回Object对象
   } catch (CloneNotSupportedException e) {
      e.printStackTrace();
   }
   return sheep;
}
1
2
3
4
5
6
7
8
9
10
11
12

在Client.java测试

``

public static void main(String[] args) {
   System.out.println("原型模式完成对象的创建");

   Sheep sheep = new Sheep("tom", 1, "白色");
   
   Sheep sheep2 = (Sheep)sheep.clone(); //克隆
   Sheep sheep3 = (Sheep)sheep.clone(); //克隆
   Sheep sheep4 = (Sheep)sheep.clone(); //克隆
   Sheep sheep5 = (Sheep)sheep.clone(); //克隆
   }

}
1
2
3
4
5
6
7
8
9
10
11
12

4、原型模式在Spring框架的源码分析

在beans.xml中使用原型模式创建对象

``

 <!-- 这里我们的 scope="prototype" 即 原型模式来创建 -->
 <bean id="id01" class="com.atguigu.spring.bean.Monster" 
   scope="prototype"/>
 
</beans>
1
2
3
4
5

Monster.java

``

public class Monster {

   private Integer id = 10 ;
   private String nickname = "牛魔王";
   private String skill = "芭蕉扇";
  
   /**
   属性的构造方法和getter and setter方法以及toString方法省略
   **/
   
}
1
2
3
4
5
6
7
8
9
10
11

测试

``

public static void main(String[] args) {
   
   ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
   // 获取monster[通过id获取monster]
   Object bean = applicationContext.getBean("id01");
   System.out.println("bean" + bean); // 输出 "牛魔王" .....
   
   Object bean2 = applicationContext.getBean("id01");
   
   System.out.println("bean2" + bean2); //输出 "牛魔王" .....

   System.out.println(bean == bean2); // false
   
   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在 Object bean = applicationContext.getBean(“id01”);处打断点debug追踪发现执行过程中会判断是否是哪种模式，例如单例、原型

具体源码分析待专门研究Spring源码时弄透彻

四、浅拷贝和深拷贝

1、浅拷贝介绍

• 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
• 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

前面所说的克隆羊就是浅拷贝，浅拷贝是使用默认的clone()方法实现

sheep = (Sheep) super.clone();

2、深拷贝介绍

1. 复制对象的所有基本数据类型的成员变量值

2. 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

   深拷贝实现方式 1：重写 clone 方法来实现深拷贝

深拷贝实现方式 2：通过对象序列化实现深拷贝(推荐)

3、代码实现深拷贝

方式一：

创建一个pojo对象，目的是为了引用它

``

public class DeepCloneableTarget implements Serializable, Cloneable {

   private static final long serialVersionUID = 1L;

   private String cloneName;

   private String cloneClass;

   //构造器
   public DeepCloneableTarget(String cloneName, String cloneClass) {
      this.cloneName = cloneName;
      this.cloneClass = cloneClass;
   }

   //因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
   @Override
   protected Object clone() throws CloneNotSupportedException {
      return super.clone();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在DeepProtoType.java中实现深拷贝

``

public class DeepProtoType implements Serializable, Cloneable{

   public String name; //String 属性
   public DeepCloneableTarget deepCloneableTarget;// 引用类型
   public DeepProtoType() {
      super();
   }


   //深拷贝 - 方式 1 使用clone 方法
   @Override
   protected Object clone() throws CloneNotSupportedException {

      Object deep = null;
      //这里完成对基本数据类型(属性)和String的克隆
      deep = super.clone();
      //对引用类型的属性，进行单独处理
      DeepProtoType deepProtoType = (DeepProtoType)deep;
      deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();

      return deepProtoType;
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试使用clone方式进行深拷贝

``

public static void main(String[] args) throws Exception {

   DeepProtoType p = new DeepProtoType();
   p.name = "宋江";
   p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");

   //方式1 完成深拷贝

   DeepProtoType p2 = (DeepProtoType) p.clone();

   System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
   System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

可以看到对String类型的属性进行了拷贝，对引用类型的属性也进行了深拷贝，hashCode不相同。

方式二：

在DeepProtoType.java加入

``

//深拷贝 - 方式2 通过对象的序列化实现 (推荐)

public Object deepClone() {

   //创建流对象
   ByteArrayOutputStream bos = null;
   ObjectOutputStream oos = null;
   ByteArrayInputStream bis = null;
   ObjectInputStream ois = null;

   try {

      //序列化
      //输出对象流
      bos = new ByteArrayOutputStream();
      oos = new ObjectOutputStream(bos);
      oos.writeObject(this); //当前这个对象以对象流的方式输出

      //反序列化
      //将输出的对象流读进来，实现克隆
      bis = new ByteArrayInputStream(bos.toByteArray());
      ois = new ObjectInputStream(bis);
      DeepProtoType copyObj = (DeepProtoType)ois.readObject();

      return copyObj;

   } catch (Exception e) {
      e.printStackTrace();
      return null;
   } finally {
      //关闭流
      try {
         bos.close();
         oos.close();
         bis.close();
         ois.close();
      } catch (Exception e2) {
        
         System.out.println(e2.getMessage());
      }
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

主函数测试

//方式2 完成深拷贝
DeepProtoType p2 = (DeepProtoType) p.deepClone();

System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
1
2
3
4
5

五、原型模式注意事项

1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。

2. 不用重新初始化对象，而是动态的获得对象运行时的状态

3. 如果原始对象发生了变化（增加或减少属性），其他克隆对象的属性也会发生响应变化，而无需修改代码

4. 在实现深克隆时可能需要较复杂代码

5. 缺点：

   ​ 需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则

下一期预告： 建造者模式