常用设计模式系列（五）—原型模式

GOF设计模式, UML类图, 设计模式 Comments

一、前言

各位朋友大家好，经过几天的努力，我已经讲解了常用设计模式其中的四种，分别是简单工厂、工厂方法、抽象工厂、建造者模式，正在想着下一遍写哪个模式的时候，有个朋友先说他想先看看原型模式，说想看看原型模式是如何运行的，然后我给这个朋友讲了个故事：“从前有个老铁得了个病，听说还挺严重的，后来经过询问，他得的是没毛病，加起来就是老铁！没毛病”。

img

如何引入原型模式呢？每位程序员在编程的过程中，在A工程的中进行了程序编写，编写一个很好用的工具，在B系统使用时发现也有相似的场景需要使用，那这个时候会去A工程把需要用的代码拷贝到B工程，这个复制粘贴的过程，就是原型模式的思想。

二、原型模式概念

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

原型模式主要表现形式，提供一个实例，通过代码去复制这个实例获得新对象。

主要结构：

  1. 抽象原型类（Abstrct Prototype）：规定了具体原型对象必须实现的接口。
  2. 具体原型类(Concrete Prototype)：实现抽象原型类的 clone() 方法，它是可被复制的对象。
  3. 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

场景举例：

​ 讲个场景，一位朋友租了一个房子，房东给了一把钥匙，然后他想给他女朋友配一把新的钥匙（ps：他有女朋友，你扎心不?老铁），然后他拿着这个要是找到了配钥匙的大爷，大爷拿着原有的钥匙，给配了一把一模一样的钥匙，这个配置的方式，也叫克隆，两个本体极为相似，但又不是一个本体，这个模式就叫做原型模式。

克隆模式分类：

  • 浅克隆：使用克隆后，克隆好的对象与原对象不同，但是对象内的成员（成员对象、成员变量）引用地址相同。
  • 深克隆：使用克隆后，克隆好的对象以及对象内的成员成员对象、成员变量）引用地址都不同。

解释：一个人拥有一部手机，浅克隆就是克隆了这个人，但是手机是两个人共享，但是深克隆就是人和手机都被克隆了，每个人都拥有自己的手机。

UML图（浅克隆）

img

三、代码实现

使用自定义方法实现浅克隆

1.编写抽象原型，定义抽象方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.yang.prototype;

import com.sun.deploy.net.protocol.ProtocolType;

/**
 * @ClassName AbstractPrototype
 * @Description 抽象原型
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:34
 * @Version 1.0
 **/
public interface AbstractPrototype<T> {
    /**
     * 自定义克隆方法
     * @return
     */
    public T clone();
}

2.编写具体原型A

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
package com.yang.prototype;

import com.sun.deploy.net.protocol.ProtocolType;
import com.yang.builder.Product;

/**
 * @ClassName ConcretePrototype
 * @Description 具体原型A
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:37
 * @Version 1.0
 **/
public class ConcretePrototypeA implements AbstractPrototype<ConcretePrototypeA>{
    //实例名称
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public ConcretePrototypeA clone() {
        ConcretePrototypeA protocolType = new ConcretePrototypeA();
        protocolType.setName(this.getName().toString());
        return protocolType;
    }
}

3.编写具体原型B

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
package com.yang.prototype;

/**
 * @ClassName ConcretePrototype
 * @Description 具体原型B
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:37
 * @Version 1.0
 **/
public class ConcretePrototypeB implements AbstractPrototype<ConcretePrototypeB>{
    //实例名称
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public ConcretePrototypeB clone() {
        ConcretePrototypeB protocolType = new ConcretePrototypeB();
        protocolType.setName(this.getName());
        return protocolType;
    }
}

4.编写客户端测试

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
package com.yang.prototype;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName Client
 * @Description 注释
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:42
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) throws Exception{
        //具体原型对象创建
        ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
        //设置名称
        concretePrototype.setName("我是十字钥匙");
        //克隆对象
        ConcretePrototypeA concretePrototypeA1 = concretePrototype.clone();
        //打印克隆的名称
        System.out.println(concretePrototypeA1.getName());
        //查看是否是同一个对象
        System.out.println("ConcretePrototypeA对象对比："+(concretePrototype == concretePrototypeA1));
        //查看成员变量引用
        System.out.println("ConcretePrototypeA对象成员变量引用对比："+(concretePrototype.getName() == concretePrototypeA1.getName()));

        //具体原型对象创建
        ConcretePrototypeB concretePrototypeB = new ConcretePrototypeB();
        //设置名称
        concretePrototypeB.setName("我是电子钥匙");
        //克隆对象concretePrototype
        ConcretePrototypeB concretePrototypeB1 = concretePrototypeB.clone();
        //打印克隆的名称
        System.out.println(concretePrototypeB1.getName());
        //查看是否是同一个对象
        System.out.println("ConcretePrototypeB对象对比："+(concretePrototypeB == concretePrototypeB1));
        //查看成员变量引用
        System.out.println("ConcretePrototypeB对象成员变量引用对比："+(concretePrototypeB.getName() == concretePrototypeB1.getName()));
    }
}

5.测试结果如下：

1
2
3
我是十字钥匙
ConcretePrototypeA对象对比：false
ConcretePrototypeA对象成员变量引用对比：true

测试结论：

由测试结果可以看出，使用浅克隆方式的对象，与原对象的引用地址不同，但是内部成员变量的地址是相同的。

我们都知道Java中的超类是Object，每个对象的最终级别父类都是Object，Object也提供了clone方法,那它是浅拷贝还是深拷贝呢？我们看下源码。

img

发现源码中方法为native类型的，native类型的方法已经是非Java语言编写的了，是Java本身对底层的访问与操作，是其他语言编写的，不能够再通过Java编辑器找到具体代码。代码上声明了CloneNotSupportedException异常，并且写了注释，我们可以通过注释(if the object’s class does not support the {@code Cloneable} interface. Subclasses that override the {@code clone} method can also throw this exception to indicate that an instance cannot be cloned.)看到，如果一个类没有实现Cloneable接口，但是这个类重写了clone方法，那这个类将不能被克隆且会抛出CloneNotSupportedException异常。我们来使用代码尝试下clone。

Object的clone实现克隆

1.编写原型ConcretePrototypeC，重写下clone方法

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
package com.yang.prototype;

/**
 * @ClassName ConcretePrototypeC
 * @Description 注释
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:34
 * @Version 1.0
 **/
public class ConcretePrototypeC {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected ConcretePrototypeC clone() throws CloneNotSupportedException {
        return (ConcretePrototypeC)super.clone();
    }
}

2.编写客户端测试

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
package com.yang.prototype;

/**
 * @ClassName ClentTest
 * @Description 注释
 * @Author IT小白架构师之路
 * @Date 2020/12/11 17:35
 * @Version 1.0
 **/
public class ClientTest {
    public static void main(String[] args) throws Exception{
        //创建原型产品
        ConcretePrototypeC concretePrototypeC = new ConcretePrototypeC();
        concretePrototypeC.setName("手机");
        //克隆
        ConcretePrototypeC concretePrototypeC1 = concretePrototypeC.clone();
        //打印克隆的名称
        System.out.println(concretePrototypeC1.getName());
        //查看是否是同一个对象
        System.out.println("ConcretePrototypeA对象对比："+(concretePrototypeC == concretePrototypeC1));
        //查看成员变量引用
        System.out.println("ConcretePrototypeA对象成员变量引用对比："+(concretePrototypeC.getName() == concretePrototypeC1.getName()));

    }
}

3.程序运行结果，由于未实现Cloneable接口，代码抛出了java.lang.CloneNotSupportedException异常

1
2
3
4
Exception in thread "main" java.lang.CloneNotSupportedException: com.yang.prototype.ConcretePrototypeC
	at java.lang.Object.clone(Native Method)
	at com.yang.prototype.ConcretePrototypeC.clone(ConcretePrototypeC.java:23)
	at com.yang.prototype.ClientTest.main(ClientTest.java:16)

4.给ConcretePrototypeC加上实现Cloneable接口后，代码运行结果如下

1
2
3
手机
ConcretePrototypeA对象对比：false
ConcretePrototypeA对象成员变量引用对比：true

结论：发现使用Java的clone也是使用浅拷贝，综合clone方法的注释可以判断，如果成员变量也想被克隆，那成员变量所属类也要实现Cloneable接口且重写clone方法，那如果程序每一个类都这么处理，代码开发过程将会变得极其复杂。
解释：一个人拥有一部手机，浅克隆就是克隆了这个人，但是手机是两个人共享，但是深克隆就是人和手机都被克隆了，如果想用Java的clone来完成深克隆，手机对象也要实现Cloneable以及重写clone方法，然后再人的clone方法加上mobile克隆。层级多的情况下，深克隆代码会相对复杂。

我经过查阅资料发现广大网友提供的解决方案：使用序列化+字节流的方式进行处理

序列化克隆代码实现

1.编写原型ConcretePrototypeD，自定义clone方法,注意需要实现Serializable接口

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
package com.yang.prototype;

import java.io.*;

/**
 * @ClassName ConcretePrototypeD
 * @Description 深克隆对象
 * @Author IT小白架构师之路
 * @Date 2020/12/11 18:07
 * @Version 1.0
 **/
public class ConcretePrototypeD implements Serializable{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public ConcretePrototypeD clone(){
        ConcretePrototypeD stu = null;
        try {
            //将对象序列化到流里
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);
            //将流反序列化成对象
            ByteArrayInputStream is = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(is);
            stu = (ConcretePrototypeD) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return stu;
    }
}

2.编写测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.yang.prototype;

/**
 * @ClassName ClietClone
 * @Description 注释
 * @Author IT小白架构师之路
 * @Date 2020/12/11 18:11
 * @Version 1.0
 **/
public class ClietClone {
    public static void main(String[] args) {
        //创建原型产品
        ConcretePrototypeD concretePrototypeD = new ConcretePrototypeD();
        concretePrototypeD.setName("深克隆的名字");
        //克隆产品
        ConcretePrototypeD concretePrototypeD1 = concretePrototypeD.clone();
        //查看是否是同一个对象
        System.out.println("ConcretePrototypeA对象对比："+(concretePrototypeD == concretePrototypeD1));
        //查看成员变量引用
        System.out.println("ConcretePrototypeA对象成员变量引用对比："+(concretePrototypeD.getName() == concretePrototypeD1.getName()));
    }
}

3.测试结果如下

1
2
ConcretePrototypeA对象对比：false
ConcretePrototypeA对象成员变量引用对比：false

结论：使用序列化+字节流的方式进行克隆，实现了类的深克隆。

四、优缺点分析及适用场景

优点：

1.可以简单快速的克隆对象，不需要再对成员赋值

2.可以在不关心创建细节的情况下完成对象创建

3.使用克隆比使用构造的方式快，因为虚拟机直接复制内存块执行克隆的。

缺点：

1.如果使用clone进行深拷贝，则需要很大的代码量把每一个类进行改造。

2.克隆对象时需要考虑使用深克隆还是浅克隆，否则容易在修改过程中导致原类成员数据错乱。

适用场景：

1.资源优化场景。

2.性能和安全要求的场景。

3.在类初始化需要消化非常多的资源场景时。

4.一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式的浅拷贝，拷贝多个对象供调用者使用。

5.在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者；原型模式已经与 Java 融合在一起，任何开发人员可以随手拿来使用。

Java小白_Mr.YangJava 开发工程师

个人简介。