原型模式（Prototype Pattern）

最新推荐文章于 2024-08-15 15:51:41 发布
最新推荐文章于 2024-08-15 15:51:41 发布
阅读量113 收藏
点赞数
分类专栏： 设计模式 文章标签： 原型模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37148777/article/details/128414725
版权

概念

原型模式属于创建型模式，指用实例的原型指定创建对象的种类，并通过克隆这些原型创建新的对象。

通过克隆来创建新的对象实例。一般来讲，新创建出来的实例的数据是和原型实例一样的。但是具体如何实现克隆，需要自行实现，原型模式并没有统一的要求和实现算法。

原型实例和克隆出来的实例，本质上是不同的实例，克隆完成后，它们之前是没有关联的，如果克隆完成后，克隆出来的实例的属性值发生改变，是不会影响到原型实例的。

克隆的形式

浅度克隆

只负责克隆按值传递的数据，比如基本数据类型、String类型等。

深度克隆

除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例所的属性数据都会被克隆出来。

解释一下就是：如果被克隆的对象里面的属性数据为引用类型，也就是属性的类型也是对象，则需要一直递归地克隆下去。这也意味着，要想深度克隆成功，必须是整个克隆过程中所涉及的对象都要正确的实现克隆方法，如果其中有一个没有正确的实现克隆，那么就会导致克隆失败。

克隆的方式

手动实现

顾名思义，就是手动实现克隆方法，可以按需去复制自己用到的属性。

public class PersonalOrder {

    private String customerName;
    private String productId;
    private int orderProductNum = 0;

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public int getOrderProductNum() {
        return orderProductNum;
    }

    public void setOrderProductNum(int orderProductNum) {
        this.orderProductNum = orderProductNum;
    }

    /**
     * 手动创建一个克隆方法
     */
    public PersonalOrder cloneMe() {
        // 创建克隆数据
        PersonalOrder newOrder = new PersonalOrder();
        // 将原型类中的属性值赋值到克隆类中
        newOrder.setCustomerName(this.getCustomerName());
        newOrder.setProductId(this.getProductId());
        newOrder.setOrderProductNum(this.getOrderProductNum());
        // 返回克隆好的对象
        return newOrder;
    }
}

实现Cloneable接口

在Java语言中已经提供了clone方法，定义在Object类中。需要克隆功能的类，只需要实现java.lang.Cloneable接口。

public class EnterpriseOrder implements Cloneable{
    private String enterpriseName;
    private String productId;
    private int orderProductNum = 0;

    public String getEnterpriseName() {
        return enterpriseName;
    }

    public void setEnterpriseName(String enterpriseName) {
        this.enterpriseName = enterpriseName;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public int getOrderProductNum() {
        return orderProductNum;
    }

    public void setOrderProductNum(int orderProductNum) {
        this.orderProductNum = orderProductNum;
    }

    @Override
    protected EnterpriseOrder clone() throws CloneNotSupportedException {
        // 实现Cloneable后，调用父类的克隆方法即可完成克隆
        return (EnterpriseOrder) super.clone();
    }

    @Override
    public String toString() {
        return "EnterpriseOrder{" +
                "enterpriseName='" + enterpriseName + '\'' +
                ", productId='" + productId + '\'' +
                ", orderProductNum=" + orderProductNum +
                '}';
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        EnterpriseOrder enterpriseOrder = new EnterpriseOrder();
        enterpriseOrder.setOrderProductNum(100);
        
        EnterpriseOrder enterpriseOrder1 = enterpriseOrder.clone();
        System.out.println("完成克隆时的订单数量：" + enterpriseOrder1.getOrderProductNum());
        enterpriseOrder1.setOrderProductNum(200);
        System.out.println("克隆对象修改后的订单数量：" + enterpriseOrder1.getOrderProductNum());
        System.out.println("原型对象的订单数量：" + enterpriseOrder.getOrderProductNum());
    }
}

原型管理器

如果一个系统中原型的数量不固定，比如系统中的原型可以被动态地创建和销毁，那么就需要在系统中维护一个当前可用的原型注册表，这个注册表就被称为原型管理器。

原型管理器可以理解为一个资源管理器，在系统开始运行时被初始化，然后运行期间可以动态的添加和销毁资源。从这个角度看，原型管理器就相当于一个缓存，只不过缓存的对象是原型实例而已。

原型管理器的简单实现示例：

/**
 * 定义一个原型接口：人
 */
public interface IPerson {
    public IPerson clone();
    public String getName();
    public void setName(String name);
}

/**
 * 实现原型接口：男人类
 */
public class Man implements IPerson {
    
    private String name;

    @Override
    public String getName() {
        return name;
    }

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

    // 实现克隆方法
    @Override
    public IPerson clone() {
        Man tmp = new Man();
        tmp.setName(this.name);
        return tmp;
    }

    @Override
    public String toString() {
        return "Man{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 实现原型接口：女人类
 */
public class Woman implements IPerson {

    private String name;

    // 实现克隆方法
    @Override
    public IPerson clone() {
        Woman tmp = new Woman();
        tmp.setName(this.name);
        return tmp;
    }

    @Override
    public String getName() {
        return null;
    }

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

    @Override
    public String toString() {
        return "Woman{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 原型管理器
 */
public class PrototypeManager {

    /** 用来存储原型ID和原型的对应关系 */
    private static Map<String, IPerson> PROTOTYPE_CONTAINER = new HashMap<>();
    
    /**
     * 构造方法私有化，避免外部创建实例 
     */
    private PrototypeManager() {
        
    }
    
    /**
     * 向原型管理器中添加或修改原型实例 
     * 在多线程情况下为了保证原型管理器的线程安全，使用synchronized
     * @param prototypeId: 原型ID
     * @param person: 原型实例
     * @return void
     */
    public synchronized static void setProperty(String prototypeId, IPerson person) {
        PROTOTYPE_CONTAINER.put(prototypeId, person);
    }
    
    /**
     * 在原型管理器中删除原型实例 
     * @param prototypeId: 原型ID
     * @return void
     */
    public synchronized static void removePrototype(String prototypeId) {
        PROTOTYPE_CONTAINER.remove(prototypeId);
    }
    
    /**
     * 获取原型实例 
     * @param prototypeId: 原型ID
     * @return priv.xuchen.play.manager.IPerson
     */
    public synchronized static IPerson getPrototype(String prototypeId) throws Exception {
        IPerson person = PROTOTYPE_CONTAINER.get(prototypeId);
        if (null == person) {
            throw new Exception("原型未注册，原型ID ==> " + prototypeId);
        }
        return  person;
    }


    public static void main(String[] args) throws Exception {
        // 初始化原型管理器
        IPerson p1 = new Man();
        p1.setName("xiaoming");
        PrototypeManager.setProperty("person", p1);

        // 从原型管理器中获取一个原型
        IPerson p2 = PrototypeManager.getPrototype("person");
        System.out.println("p2 ==> " + p2.toString());
        
        // 从获取的原型上创建一个新实例并使用，这里修改他的名子
        IPerson p3 = (Man) p2.clone();
        p3.setName("xiaoli");
        System.out.println("p3 ==> " + p3.toString());
        
        // 切换原型的实现
        IPerson p4 = new Woman();
        p4.setName("xiaohong");
        PrototypeManager.setProperty("person", p4);
        
        // 重新获取原型对象
        p2 = PrototypeManager.getPrototype("person");
        System.out.println("p2 ==> " + p2.toString());
        
        // 注销这个原型
        PrototypeManager.removePrototype("person");

        // 重新获取原型对象
        p2 = PrototypeManager.getPrototype("person");
    }
}

运行结果：

p2 ==> Man{name='xiaoming'}
p3 ==> Man{name='xiaoli'}
p2 ==> Woman{name='xiaohong'}
Exception in thread "main" java.lang.Exception: 原型未注册，原型ID ==> person
	at priv.xuchen.play.manager.PrototypeManager.getPrototype(PrototypeManager.java:54)
	at priv.xuchen.play.manager.PrototypeManager.main(PrototypeManager.java:88)

应用场景举例

需求：在订单系统中，有一个保存订单的业务功能。在这个功能中，由于客户的生产力原因，要求每当订单的预定产品数量超过1000的时候，就需要把订单拆分成两份订单来保存。如果拆分后的订单其中有一份还是超过1000，就继续拆分，直到每份订单的预定产品数量不超过1000。根据实际业务，目前订单类型被分成两种：个人订单和企业订单，现需要实现一个通用的订单系统，即不论是个人订单还是企业订单都可以自动处理。

/**
 * 订单接口
 */
public interface IOrder {
    
    /**
     * 获取预定产品数量 
     * @return int
     */
    public int getOrderProductNum();
    
    /**
     * 修改预定产品数量 
     * @param num: 预定产品数量
     * @return void
     */
    public void setOrderProductNum(int num);
    
    /**
     * 克隆一个实例 
     * @return priv.xuchen.play.demo3.IOrder
     */
    public IOrder clone();
    
}

/**
 * 个人订单实例
 */
public class PersonalOrder implements IOrder{
    
    private String customerName;
    private String productId;
    private int orderProductNum = 0;

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    @Override
    public int getOrderProductNum() {
        return orderProductNum;
    }
    
    @Override
    public void setOrderProductNum(int orderProductNum) {
        this.orderProductNum = orderProductNum;
    }

    @Override
    public IOrder clone() {
        PersonalOrder newOrder = new PersonalOrder();
        newOrder.setCustomerName(this.getCustomerName());
        newOrder.setProductId(this.getProductId());
        newOrder.setOrderProductNum(this.getOrderProductNum());
        return newOrder;
    }

    @Override
    public String toString() {
        return "PersonalOrder{" +
                "customerName='" + customerName + '\'' +
                ", productId='" + productId + '\'' +
                ", orderProductNum=" + orderProductNum +
                '}';
    }
    
}

/**
 * 企业订单实例
 */
public class EnterpriseOrder implements Cloneable, IOrder{
    private String enterpriseName;
    private String productId;
    private int orderProductNum = 0;

    public String getEnterpriseName() {
        return enterpriseName;
    }

    public void setEnterpriseName(String enterpriseName) {
        this.enterpriseName = enterpriseName;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    @Override
    public int getOrderProductNum() {
        return orderProductNum;
    }

    @Override
    public void setOrderProductNum(int orderProductNum) {
        this.orderProductNum = orderProductNum;
    }

    @Override
    public IOrder clone() {
        EnterpriseOrder newOrder = new EnterpriseOrder();
        newOrder.setEnterpriseName(this.getEnterpriseName());
        newOrder.setProductId(this.getProductId());
        newOrder.setOrderProductNum(this.getOrderProductNum());
        return newOrder;
    }

    @Override
    public String toString() {
        return "EnterpriseOrder{" +
                "enterpriseName='" + enterpriseName + '\'' +
                ", productId='" + productId + '\'' +
                ", orderProductNum=" + orderProductNum +
                '}';
    }
}

/**
 * 处理订单业务
 */
public class OrderBusiness {

    /**
     * 保存订单，如果预定产品数据大于1000，则拆分订单 
     * @param order: 订单原型
     * @return void
     */
    public void saveOrder(IOrder order) {
        // 判断当前预定产品数量是否大于1000
        while (order.getOrderProductNum() > 1000) {
            // 大如大于，进行订单拆分
            // 通过原型模式，克隆当前订单，修改订单数量，生成了新的符合条件的订单实现
            IOrder newOrder = order.clone();
            newOrder.setOrderProductNum(1000);
            // 原订单保留，调整预定产品数量，减1000
            order.setOrderProductNum(order.getOrderProductNum() - 1000);
            System.out.println("拆分订单==>" + newOrder);
            
            // 对拆分后的订单进行业务处理或者入库，此处省略。。。
        }

        // 不超过直接进行业务处理或者入库，此处省略。。。
        System.out.println("订单==>" + order);
    }
    
    public static void main(String[] args) {

        OrderBusiness orderBusiness = new OrderBusiness();
        
        PersonalOrder personalOrder = new PersonalOrder();
        personalOrder.setCustomerName("AAA");
        personalOrder.setProductId("productIdA");
        personalOrder.setOrderProductNum(2999);
        orderBusiness.saveOrder(personalOrder);
        
        EnterpriseOrder enterpriseOrder = new EnterpriseOrder();
        enterpriseOrder.setEnterpriseName("BBB");
        enterpriseOrder.setProductId("productIdB");
        enterpriseOrder.setOrderProductNum(3000);
        orderBusiness.saveOrder(enterpriseOrder);
    }
}

运行结果：

拆分订单==>PersonalOrder{customerName='AAA', productId='productIdA', orderProductNum=1000}
拆分订单==>PersonalOrder{customerName='AAA', productId='productIdA', orderProductNum=1000}
订单==>PersonalOrder{customerName='AAA', productId='productIdA', orderProductNum=999}
拆分订单==>EnterpriseOrder{enterpriseName='BBB', productId='productIdB', orderProductNum=1000}
拆分订单==>EnterpriseOrder{enterpriseName='BBB', productId='productIdB', orderProductNum=1000}
订单==>EnterpriseOrder{enterpriseName='BBB', productId='productIdB', orderProductNum=1000}

总结

原型模式的优缺点

优点
  1. 对客户端隐藏具体的实现类型：原型模式的客户端只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖。
  2. 在运行时动态的改变实现类型：原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态的改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个实例了。因为克隆一个原型就类似于实例化一个新类。
缺点
  1. 原型模式最大的缺点在于每个原型的子类都必须实现clone操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归地让所有的相关对象都要正确的实现克隆。

原型模式的应用场景

  1. 如果一个系统想要独立于它想要使用的对象时，可以使用原型模式，让系统只面向接口编程，在系统需要新的对象的时候，可以通过克隆原型来得到。
  2. 如果需要实例化的类是在运行时动态指定的，可以使用原型模式，通过克隆来得到需要的实例

资料参考

《研磨设计模式》 陈臣 王斌 著

xxuchen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
原型模式 Prototype Pattern
03-09
### 原型模式 Prototype Pattern #### 概述 原型模式是一种创建型设计模式，它允许用户通过复制现有的实例来创建新的对象，而不是通过传统的构造器来创建对象。这种模式适用于那些创建对象的成本较高，或者当对象...
原型模式（Prototype Pattern）原理图
04-10
原型模式是一种创建型设计模式，它通过复制一个现有的对象来创建新的对象，而不是通过调用构造函数的方式。这种方式可以在运行时动态地创建和修改对象，而不需要知道具体的创建细节 。 原型模式的基本概念包括以下...
Prototype Pattern原型模式
10-01
**原型模式(Prototype Pattern)**是一种基于克隆的创建型设计模式，它的主要目的是为了提高创建新对象的效率，特别是当创建新对象的过程复杂或者资源消耗较大时。在原型模式中，一个已经创建的对象（称为原型）被...
php示例详解Constructor Prototype Pattern 原型模式
10-23
原型模式是一种创建型设计模式，它通过复制已有的对象来创建新的对象实例，避免了重复的初始化操作，能够提高对象创建的效率。在PHP中，可以通过克隆对象的机制来实现原型模式。下面是原型模式的关键知识点： 1. ...
.NET设计模式（6）：原型模式（PrototypePattern）
01-30
### .NET设计模式（6）：原型模式（Prototype Pattern） #### 概述 在软件工程领域，设计模式提供了一系列经过验证的解决方案，帮助开发者解决常见的软件设计问题。本篇文章聚焦于.NET框架下的“原型模式”...
原型与原型链与继承
weixin_小白鼠的博客
08-14 950
构造函数创建实例的过程1.创建一个新对象2.将空对象的__proto__指向构造函数的原型3.修改构造函数中this指向，将构造函数中的this指向实例对象，执行构造函数中的代码，给这个新对象添加属性和方法（通过call/apply）4.返回新对象(实例对象)
设计模式 - 原型模式
菜鸟小码的博客
08-09 974
原型模式是一种创建型设计模式，它通过复制现有的对象实例来创建新对象，而不是通过传统的构造函数创建。这种模式适用于对象创建成本较高的场景，以及需要动态创建大量相似对象的情况。本文将详细介绍原型模式的概念，并通过具体的Java代码示例来说明如何实现这一模式。
js原型和原型链的概念
最新发布
m0_69254007的博客
08-15 213
原型和原型链是JavaScript中重要的概念，理解它们对于理解如何构建对象以及继承特性非常关键。原型：在JavaScript中，每个函数都有一个特殊的属性叫做prototype。这个属性指向一个对象，这个对象作为原型，该函数所创建的所有对象都将继承这个原型对象的属性和方法。在这个例子中，Person函数的prototype属性指向一个包含nameage和job属性的对象。当我们创建Person的新实例person1时，这个实例会从中继承这些属性。
libnl教程(1):订阅内核的netlink广播通知
大草的博客
08-13 713
libnl教程(1):订阅内核的netlink广播通知
libnl教程(2):发送请求
大草的博客
08-14 761
libnl教程(2):发送请求
JAVA进阶补充
2301_80150315的博客
08-15 551
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 875
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 543
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 249
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 823
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 935
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 689
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 262
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 972
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
原型模式(Prototype Pattern)
06-01
原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而不是通过实例化类来创建。这使得创建新对象变得更加高效，因为它避免了重复初始化和配置对象的开销。 在原型模式中，我们定义一个原型对象，它是我们要创建新对象的模板。然后我们通过复制这个原型对象来创建新的对象。这个原型对象通常是通过克隆方法来实现的，该方法复制原型并返回一个新对象的引用。 原型模式可以帮助我们在运行时动态地创建新的对象，而不需要编写大量的代码来手动初始化和配置它们。它也可以帮助我们避免对象创建时的高昂开销，因为我们可以通过复制现有对象来创建新对象，而不需要重新初始化它们的属性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值