设计模式：快速理解原型模式和应用

张彦峰ZYF

已于 2024-07-05 09:25:40 修改

阅读量10w+

点赞数 22

分类专栏：设计模式应用 JAVA基础讲解与总结文章标签：原型模式 java 开发语言

于 2020-05-12 16:46:00 首次发布

本文链接：https://blog.csdn.net/xiaofeng10330111/article/details/106079740

版权

JAVA基础讲解与总结同时被 2 个专栏收录

30 篇文章 57 订阅

订阅专栏

设计模式应用

12 篇文章 34 订阅

订阅专栏

干货分享，感谢您的阅读！

一、原型模式的定义与理解

（一）基本定义

在软件系统中，有些对象的创建过程较为复杂，而且有时候需要频繁创建，原型模式通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象，这就是原型模式。

具体GOF给出的原型模式定义如下：（使用原型实例指定将要创建的对象类型，通过复制这个实例创建新的对象。）

Specify the kind of objects to create using a prototypical instance, 
and create new objects by copying this prototype.

（二）基本理解分析

原型模式是通过给出一个原型对象来指明所创建的对象的类型，然后使用自身实现的克隆接口来复制这个原型对象，该模式就是用这种方式来创建出更多同类型的对象。

使用这种方式创建新的对象的话，就无需再通过 new 实例化来创建对象了。这是因为 Object 类的 clone 方法是一个本地方法，它可以直接操作内存中的二进制流，所以性能相对 new 实例化来说，更佳。

（三）在Spring中的具体体现

Spring 中，@Service 默认都是单例的。用了私有全局变量，若不想影响下次注入或每次上下文获取 bean，就需要用到原型模式，我们可以通过以下注解来实现，@Scope(“prototype”)。

二、具体简单实现方式

(一)实现原型类具备的三个条件

要实现一个原型类，需要具备三个条件：

实现 Cloneable 接口：Cloneable 接口与序列化接口的作用类似，它只是告诉虚拟机可以安全地在实现了这个接口的类上使用 clone 方法。在 JVM 中，只有实现了 Cloneable 接口的类才可以被拷贝，否则会抛出 CloneNotSupportedException 异常。

重写 Object 类中的 clone 方法：在 Java 中，所有类的父类都是 Object 类，而 Object 类中有一个 clone 方法，作用是返回对象的一个拷贝。

在重写的 clone 方法中调用 super.clone()：默认情况下，类不具备复制对象的能力，需要调用 super.clone() 来实现。

（二）具体举例

此处简单实现一个员工类的原型模式，复杂问题及深拷贝、浅拷贝问题暂时不考虑，具体实现如下：

/**
 * 描述：原型模式具体案例
 *
 * @author yanfengzhang
 * @date 2020-05-26 10:39
 */
@Data
public class EmployeePrototype implements Cloneable {
    private String name;

    /**
     * 功能描述：原型抽象类需要实现Cloneable接口,重写clone方法
     *
     * @author yanfengzhang
     * @date 2020-05-26 10:49
     */
    @Override
    public EmployeePrototype clone() {
        EmployeePrototype employeePrototype = null;
        try {
            employeePrototype = (EmployeePrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return employeePrototype;
    }

    public static void main(String[] args) {
        EmployeePrototype employeePrototype1 = new EmployeePrototype();
        employeePrototype1.setName("zhangyanfeng");

        EmployeePrototype employeePrototype2 = employeePrototype1.clone();
        employeePrototype2.setName("zhouyi");

        System.out.println("原型模式测验，当前员工1姓名为：" + employeePrototype1.getName());
        System.out.println("原型模式测验，当前员工2姓名为：" + employeePrototype2.getName());
    }
}

通过 clone 方法复制的对象才是真正的对象复制，clone 方法赋值的对象完全是一个独立的对象（这块涉及深拷贝、浅拷贝的理解）。Object 类的 clone 方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

三、深拷贝、浅拷贝与原型模式的解决方案

（一）理解复制的含义，去除原有的误解

有时我们会误以为 Object a=new Object();Object b=a; 这种形式就是一种对象复制的过程，然而这种复制只是对象引用的复制，也就是 a 和 b 对象指向了同一个内存地址，如果 b 修改了，a 的值也就跟着被修改了。

与前面的简单实现相对应实现如下：

/**
 * 描述：对复制的理解分析
 *
 * @author yanfengzhang
 * @date 2020-05-26 11:06
 */
@Data
public class EmployeePrototypeTest {
    private String name;

    public static void main(String[] args) {
        EmployeePrototypeTest employeePrototypeTest1 = new EmployeePrototypeTest();
        employeePrototypeTest1.setName("zhangyanfeng");

        EmployeePrototypeTest employeePrototypeTest2 = employeePrototypeTest1;
        employeePrototypeTest2.setName("zhouyi");

        System.out.println("未使用clone方法实现的复制，只是对象引用的复制，测试结果如下：");
        System.out.println("原型模式测验，当前员工1姓名为：" + employeePrototypeTest1.getName());
        System.out.println("原型模式测验，当前员工2姓名为：" + employeePrototypeTest2.getName());

        EmployeePrototype employeePrototype1 = new EmployeePrototype();
        employeePrototype1.setName("zhangyanfeng");

        EmployeePrototype employeePrototype2 = employeePrototype1.clone();
        employeePrototype2.setName("zhouyi");

        System.out.println("使用clone方法实现的复制，测试结果如下：");
        System.out.println("原型模式测验，当前员工1姓名为：" + employeePrototype1.getName());
        System.out.println("原型模式测验，当前员工2姓名为：" + employeePrototype2.getName());
    }
}

具体输入如下：

未使用clone方法实现的复制，只是对象引用的复制，测试结果如下：
原型模式测验，当前员工1姓名为：zhouyi
原型模式测验，当前员工2姓名为：zhouyi
使用clone方法实现的复制，测试结果如下：
原型模式测验，当前员工1姓名为：zhangyanfeng
原型模式测验，当前员工2姓名为：zhouyi

（二）浅拷贝及其带来的问题

在调用 super.clone() 方法之后，首先会检查当前对象所属的类是否支持 clone，也就是看该类是否实现了 Cloneable 接口。如果支持，则创建当前对象所属类的一个新对象，并对该对象进行初始化，使得新对象的成员变量的值与当前对象的成员变量的值一模一样，但对于其它对象的引用以及 List 等类型的成员属性，则只能复制这些对象的引用了。简单调用 super.clone() 这种克隆对象方式，就是一种浅拷贝。

1.新建一个上司类作为员工类的某个属性

/**
 * 描述：复合形势下的原型模式，对员工增加对应的上司
 *
 * @author yanfengzhang
 * @date 2020-05-26 11:20
 */
@Data
public class SupervisorPrototype implements Cloneable {
    private String name;

    /**
     * 功能描述：原型抽象类需要实现Cloneable接口,重写clone方法
     *
     * @author yanfengzhang
     * @date 2020-05-26 10:49
     */
    @Override
    public SupervisorPrototype clone() {
        SupervisorPrototype supervisorPrototype = null;
        try {
            supervisorPrototype = (SupervisorPrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return supervisorPrototype;
    }
}

2.测试浅拷贝带来的问题

/**
 * 描述：需要注意浅拷贝带来的问题
 *
 * @author yanfengzhang
 * @date 2020-05-26 11:19
 */
@Data
public class EmploteeSupervisorPrototype implements Cloneable {
    private String name;
    private SupervisorPrototype supervisorPrototype;

    @Override
    public EmploteeSupervisorPrototype clone() {
        EmploteeSupervisorPrototype emploteeSupervisorPrototype = null;
        try {
            emploteeSupervisorPrototype = (EmploteeSupervisorPrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return emploteeSupervisorPrototype;
    }

    public static void main(String[] args) {
        SupervisorPrototype supervisorPrototype = new SupervisorPrototype();
        supervisorPrototype.setName("zhangyanfeng 1");

        EmploteeSupervisorPrototype emploteeSupervisorPrototype1 = new EmploteeSupervisorPrototype();
        emploteeSupervisorPrototype1.setName("zhouyi 1");
        emploteeSupervisorPrototype1.setSupervisorPrototype(supervisorPrototype);

        EmploteeSupervisorPrototype emploteeSupervisorPrototype2 = emploteeSupervisorPrototype1.clone();
        emploteeSupervisorPrototype2.setName("zhouyi 2");
        emploteeSupervisorPrototype2.getSupervisorPrototype().setName("zhangyanfeng 2");

        System.out.println("员工" + emploteeSupervisorPrototype1.getName() + "的上司是：" + emploteeSupervisorPrototype1.getSupervisorPrototype().getName());
        System.out.println("员工" + emploteeSupervisorPrototype2.getName() + "的上司是：" + emploteeSupervisorPrototype2.getSupervisorPrototype().getName());

    }
}

打印结果如下：

员工zhouyi 1的上司是：zhangyanfeng 2
员工zhouyi 2的上司是：zhangyanfeng 2

可以发现：在我们给员工 zhouyi 2 修改对应上司的时候，员工 zhouyi 1的对应上司也跟着被修改了。这就是浅拷贝带来的问题。

（三）通过深拷贝来解决问题

我们可以通过深拷贝来解决这种问题，其实深拷贝就是基于浅拷贝来递归实现具体的每个对象，代码如下：

/**
 * 描述：通过深拷贝解决浅拷贝所带来的问题
 *
 * @author yanfengzhang
 * @date 2020-05-26 13:44
 */
@Data
public class EmploteeSupervisorWithDeepPrototype implements Cloneable {

    private String name;
    private SupervisorPrototype supervisorPrototype;

    @Override
    public EmploteeSupervisorWithDeepPrototype clone() {
        EmploteeSupervisorWithDeepPrototype emploteeSupervisorWithDeepPrototype = null;
        try {
            emploteeSupervisorWithDeepPrototype = (EmploteeSupervisorWithDeepPrototype) super.clone();
            SupervisorPrototype supervisorPrototype = this.supervisorPrototype.clone();
            emploteeSupervisorWithDeepPrototype.setSupervisorPrototype(supervisorPrototype);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return emploteeSupervisorWithDeepPrototype;
    }

    public static void main(String[] args) {
        SupervisorPrototype supervisorPrototype = new SupervisorPrototype();
        supervisorPrototype.setName("zhangyanfeng 1");

        EmploteeSupervisorWithDeepPrototype emploteeSupervisorWithDeepPrototype1 = new EmploteeSupervisorWithDeepPrototype();
        emploteeSupervisorWithDeepPrototype1.setName("zhouyi 1");
        emploteeSupervisorWithDeepPrototype1.setSupervisorPrototype(supervisorPrototype);

        EmploteeSupervisorWithDeepPrototype emploteeSupervisorWithDeepPrototype2 = emploteeSupervisorWithDeepPrototype1.clone();
        emploteeSupervisorWithDeepPrototype2.setName("zhouyi 2");
        emploteeSupervisorWithDeepPrototype2.getSupervisorPrototype().setName("zhangyanfeng 2");

        System.out.println("员工" + emploteeSupervisorWithDeepPrototype1.getName() + "的上司是：" + emploteeSupervisorWithDeepPrototype1.getSupervisorPrototype().getName());
        System.out.println("员工" + emploteeSupervisorWithDeepPrototype2.getName() + "的上司是：" + emploteeSupervisorWithDeepPrototype2.getSupervisorPrototype().getName());

    }
}

运行结果为：

员工zhouyi 1的上司是：zhangyanfeng 1
员工zhouyi 2的上司是：zhangyanfeng 2

四、原型模式的应用场景分析

使用new关键字创建类的时候必须指定类名，但是在开发过程中也会有“在不指定类名的前提下生成实例”的需求。

例如，在下面这些情况下，就需要根据现有的实例来生成新的实例。

1) 对象种类繁多，无法将他们整合到一个类的时候；
2) 难以根据类生成实例时；
3) 想解耦框架与生成的实例时。

如果想要让生成实例的框架不再依赖于具体的类，这时，不能指定类名来生成实例，而要事先“注册”一个“原型”实例，然后通过复制该实例来生成新的实例。

参考书籍、文献和资料

1.《Sring 5 核心原理与30个类手写实战》，谭勇徳，中国公信出版社，2019.

2.极客时间课程《Java性能调优实战》，刘超，2019.

3.原型模式_川峰的博客-CSDN博客

4.https://blog.csdn.net/qq_34337272/article/details/80706444?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%8E%9F%E5%9E%8B%E6%A8%A1%E5%BC%8F%E7%9A%84%E5%AE%9A%E4%B9%89&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~sobaiduweb~default-1-80706444

张彦峰ZYF

关注

22
点赞
踩
30

收藏

觉得还不错? 一键收藏
打赏
18
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录