设计模式——原型模式

一、基本介绍

● 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
● 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节。
● 工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对像拷贝它们自己来实现创建，及对象的clone()。

二、类图

原理结构图说明 ：1）、Prototype：原型类，声明一个克隆自己的接口 clone。
2）、ConcretePrototype：具体的原型类，实现一个克隆自己的操作。
3）、Client 让一个原型对象克隆自己，从而创建一个新的对象（相当于属性）。

三、原型模式案例分析

【1】克隆类需要实现 Cloneable 重写 clone 方法。

 1 package com.yintong.principle.singleresponsibility;
 2 //写一个手机的克隆类
 3 public class ConcretePrototype implements Cloneable{
 4     //名称
 5     private String name;
 6     //号码
 7     private Long number;
 8     //构造器
 9     public ConcretePrototype(String name, Long number) {
10         super();
11         this.name = name;
12         this.number = number;
13     }
14 
15     @Override
16     public String toString() {
17         return "ConcretePrototype [name=" + name + ", number=" + number + "]";
18     }
19         // 克隆用到的主要部分
20     @Override
21     protected Object clone() throws CloneNotSupportedException {
22         ConcretePrototype ConcretePrototype = null;
23         try {
24             ConcretePrototype = (ConcretePrototype) super.clone();
25         }catch (Exception e) {
26             System.out.println(e.getMessage());
27         }
28         return ConcretePrototype;
29     }
30 }

【2】客户端调用 clone 方法，实现原型模式。

1 public class Client {
2     public static void main(String[] args) throws CloneNotSupportedException {
3         //创建一个对象
4         ConcretePrototype prototype = new ConcretePrototype("华为", new Long(1568889932));
5         //通过原型模式完成对象的创建  克隆
6         ConcretePrototype p2 = (ConcretePrototype)prototype.clone();
7     }
8 }

四、Spring 中的应用

【1】当 scope 配置为 prototype 时，表示原型模式。

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

【2】查看底层调用：

 1 else if (mbd.isPrototype()) {
 2     // It's a prototype -> create a new instance.
 3     Object prototypeInstance = null;
 4     try {
 5         beforePrototypeCreation(beanName);
 6             prototypeInstance = createBean(beanName, mbd, args);
 7     }
 8     finally {
 9         afterPrototypeCreation(beanName);
10     }
11         // ***  创建一个代理类  ***
12     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
13 }

五、浅拷贝

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

六、深拷贝

● 复制对象的所有基本数据类型的成员变量值
● 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
● 深拷贝的实现方式有两种，第一种是重写 clone 方法来实现深拷贝，第二种是通过序列化实现深拷贝，也是推荐的一种。

七、深克隆的两种实现方法

【1】通过调用引用类型的克隆方法，实现深拷贝。缺点就是当引用类型多时，不建议采用。

 1 public class DeepClone implements Cloneable{
 2     //基本数据类型
 3     private String name;
 4     //引用数据类型
 5     private Spare spare;
 6     
 7     //重写clone方法，调用引用类型的克隆方法
 8     @Override
 9     protected Object clone() throws CloneNotSupportedException {
10         DeepClone deepClone = null;
11         deepClone = (DeepClone)super.clone();
12         
13         //克隆引用数据类型
14         deepClone.spare = (Spare) spare.clone();
15         return deepClone;
16     }
17 }

【2】通过序列化的方式，实现深拷贝：也是建议使用的方法。

 1 public class DeepClone implements Serializable{
 2     /**
 3      * 序列化 ID
 4      */
 5     private static final long serialVersionUID = 1L;
 6     //数据类型  略。。。。
 7     //重写clone方法，调用引用类型的克隆方法
 8     protected Object deepClone(){
 9         ByteArrayOutputStream BOStream = null;
10         ObjectOutputStream OOSream = null;
11         ByteArrayInputStream BIStream = null;
12         ObjectInputStream OIStream =null;
13         try {
14             //序列化
15             BOStream = new ByteArrayOutputStream();
16             OOSream = new ObjectOutputStream(BOStream);
17             //将当前对象写入流中
18             OOSream.writeObject(this);
19             
20             //反序列化
21             BIStream = new ByteArrayInputStream(BOStream.toByteArray());
22             OIStream = new ObjectInputStream(BIStream);
23             DeepClone deepClone = (DeepClone) OIStream.readObject();
24             return deepClone;
25         } catch (Exception e) {
26             e.printStackTrace();
27             return null;
28         }finally {
29             try {
30                 BOStream.close();
31                 OOSream.close();
32                 BIStream.close();
33                 OIStream.close();
34             } catch (Exception e2) {
35                 e2.printStackTrace();
36             }
37         }
38     }
39 }

八、原型模式的注意事项和细节

1）、创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
2）、不用重新初始化对象，而是动态地获得对象运行时的状态。
3）、如果原始对象发生变化（增加或者减少属性），其他克隆对象也会发生变化，无需修改代码。
4）、在实现深克隆的时候可能需要比较复杂的代码。
5）、缺点：需要为每一个配置类配置一个克隆方法，这对全新的类来说不是很难,但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则。

----关注公众号，获取更多内容----

posted @ 2020-11-19 14:35 Java程序员进阶阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java程序员进阶