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

第一节

前言

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

    

    

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

第二节

原型模式概念

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

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

        主要结构：

1

抽象原型类（Abstrct Prototype）：规定了具体原型对象必须实现的接口。

2

具体原型类(Concrete Prototype)：实现抽象原型类的 clone() 方法，它是可被复制的对象。

3

访问类：使用具体原型类中的 clone() 方法来复制新的对象。

  场景举例

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

   克隆模式分类

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

        深克隆：使用克隆后，克隆好的对象以及对象内的成员成员对象、成员变量）引用地址都不同。

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

       UML图（浅克隆）

第三节

原型模式代码实现

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

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

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

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

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.编写客户端测试

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.测试结果如下：

我是十字钥匙ConcretePrototypeA对象对比：falseConcretePrototypeA对象成员变量引用对比：true我是电子钥匙ConcretePrototypeB对象对比：falseConcretePrototypeB对象成员变量引用对比：true

   测试结论

        由测试结果可以看出，使用浅克隆方式的对象，与原对象的引用地址不同，但是内部成员变量的地址是相同的。我们都知道Java中的超类是Object，每个对象的最终级别父类都是Object，Object也提供了clone方法,那它是浅拷贝还是深拷贝呢？我们看下源码。

        发现源码中方法为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方法

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.编写客户端测试

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异常

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接口后，代码运行结果如下

手机ConcretePrototypeA对象对比：falseConcretePrototypeA对象成员变量引用对比：true

   测试结论

结论：发现使用Java的clone也是使用浅拷贝，综合clone方法的注释可以判断，如果成员变量也想被克隆，那成员变量所属类也要实现Cloneable接口且重写clone方法，那如果程序每一个类都这么处理，代码开发过程将会变得极其复杂。

解释：一个人拥有一部手机，浅克隆就是克隆了这个人，但是手机是两个人共享，但是深克隆就是人和手机都被克隆了，如果想用Java的clone来完成深克隆，手机对象也要实现Cloneable以及重写clone方法，然后再人的clone方法加上mobile克隆。层级多的情况下，深克隆代码会相对复杂。

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

  序列化克隆代码实现

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

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.编写测试类

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.测试结果如下

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

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

第四节

优缺点分析及适用场景

优点：

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

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

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

缺点：

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

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

适用场景：

        1.资源优化场景。

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

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

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

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