【Java用法】Java设计模式之（三）原型模式（Prototype Pattern）

妖狐艹你老母 2022-10-28 12:25 130阅读 0赞

**目录**

一、原型模式简介

1.1、原型模式简介

1.2、原型模式角色

1.3、原型模式优缺点

1.4、原型模式使用场景

1.5、浅拷贝与深拷贝

二、原型模式实现

2.1 代码客户端

2.2 浅拷贝代码

2.3 深拷贝代码

三、原码分析

--------------------

# 一、原型模式简介 #

## 1.1、原型模式简介 ##

原型模式使用原型实例指定创建对象的种类，并且通过拷贝原型对象创建新的对象。

Prototype模式提供了一个通过已存在对象进行新对象创建的接口（clone）， clone()实现和具体的语言相关，在C++中通过拷贝构造函数实现。

原型模式实际上就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。在初始化的信息不发生变化的情况下，克隆是最好的办法，既隐藏了对象创建的细节，又大大提高了性能。因为如果不用clone，每次new都需要执行一次构造函数，如果构造函数的执行时间很长，那么多次的执行初始化操作就太低效了。

原型模式实现clone接口的时候必须使用深拷贝。

原型模式重点在从自身赋值自己创建新的类对象，隐藏创建的细节。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70][]

> 这种不通过 new 关键字来产生一个对象，而是通过对象拷贝来实现的模式就叫做原型模式。其通用类图如上所示。

## 1.2、原型模式角色 ##

抽象原型（Prototype）角色：规定了具体原型对象必须实现的接口（如果要提供深拷贝，则必须具有实现clone的规定）。

具体原型（ConcretePrototype）：从抽象原型派生而来，是客户程序使用的对象，即被复制的对象，需要实现抽象原型角色所要求的接口。

客户（Client）角色：使用原型对象的客户程序。

## 1.3、原型模式优缺点 ##

优点：

A、原型模式对客户隐藏了具体的产品类

B、运行时刻增加和删除产品： 原型模式允许只通过客户注册原型实例就可以将一个新的具体产品类并入系统。

C、改变值以指定新对象： 高度动态的系统允许通过对象复合定义新的行为。如通过为一个对象变量指定值并且不定义新的类。通过实例化已有类并且将实例注册为客户对象的原型，就可以有效定义新类别的对象。客户可以将职责代理给原型，从而表现出新的行为。

D、改变结构以指定新对象：许多应用由部件和子部件来创建对象。  
E、减少子类的构造，Prototype模式克隆一个原型而不是请求一个工厂方法去产生一个新的对象。

F、用类动态配置应用 一些运行时刻环境允许动态将类装载到应用中。

G、使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

H、使用原型模式的另一个好处是简化对象的创建，使得创建对象很简单。

缺点：

原型模式的主要缺陷是每一个抽象原型Prototype的子类都必须实现clone操作，实现clone函数可能会很困难。当所考虑的类已经存在时就难以新增clone操作，当内部包括一些不支持拷贝或有循环引用的对象时，实现克隆可能也会很困难的。

## 1.4、原型模式使用场景 ##

原型模式的主要思想是基于现有的对象克隆一个新的对象出来，一般是由对象的内部提供克隆的方法，通过clone方法返回一个对象的副本。

原型模式使用场景：

A、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等；

B、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；

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

在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone的方法创建一个对象，然后由工厂方法提供给调用者。

## 1.5、浅拷贝与深拷贝 ##

A、浅拷贝

被拷贝对象的所有变量都含有与原对象相同的值，而且对其他对象的引用仍然是指向原来的对象。即浅拷贝只负责当前对象实例，对引用的对象不做拷贝。

B、深拷贝

被拷贝对象的所有的变量都含有与原来对象相同的值，除了引用其他对象的变量。引用其他对象的变量将指向一个被拷贝的新对象，而不再是原有被引用对象。即深拷贝把要拷贝的对象所引用的对象也都拷贝了一次。

深拷贝要深入到多少层，是一个不确定的问题。在决定以深拷贝的方式拷贝一个对象的时候，必须决定对间接拷贝的对象是采取浅拷贝还是深拷贝还是继续采用深拷贝。因此，在采取深拷贝时，需要决定多深才算深。此外，在深拷贝的过程中，很可能会出现循环引用的问题。

# 二、原型模式实现 #

> 所有设计模式的代码实现例子都可在码云上查看哦，感兴趣的可以查看哈，码云地址：[https://gitee.com/no8g/java-design-patterns][https_gitee.com_no8g_java-design-patterns]

## 2.1 代码客户端 ##

public class Client {
 
 /**
 * 发送账单的数量，这个值是从数据库中获得
 */
 public static final int MAX_COUNT = 10000;
 
 public static void main(String[] args) {
 // 模拟发送邮件
 int i = 0;
 
 // 把模板定义出来，这个是从数据库中获得
 Mail mail = new Mail(new AdvTemplate());
 mail.setTail("XX银行版权所有");
 long startTime = System.currentTimeMillis();
 while (i < MAX_COUNT) {
 // 以下是每封邮件不同的地方
 Mail cloneMail = mail.clone();
 cloneMail.setAppellation(getRandString(5) + "先生（女士）");
 cloneMail.setReceiver(getRandString(8) + "@" + getRandString(5) + ".com");
 
 // 然后发送邮件
 sendMail(cloneMail);
 i++;
 }
 
 System.out.println("总共耗时： " + (System.currentTimeMillis() - startTime) + "毫秒");
 }
 
 public static void sendMail(Mail mail) {
 System.out.println("标题：" + mail.getSubject() + "\t收件人：" + mail.getReceiver() + "\t .....发送成功！");
 }
 
 /**
 * 获得指定长度的随机字符串
 *
 * @return 随机字符串
 */
 public static String getRandString(int maxLength) {
 
 String source ="abcdefghijklmnopqrskuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 StringBuilder sb = new StringBuilder();
 Random random = new Random();
 for (int i = 0; i < maxLength; i++) {
 sb.append(source.charAt(random.nextInt(source.length())));
 }
 
 return sb.toString();
 }
 }

package com.iot.practice.designpattern.prototype;
 
 /**
 * AdvTemplate 此类用于：
 * @author：hujm
 * @date：2021年02月06日 10:01
 * @remark：在类图中 AdvTemplate 是广告信的模板，一般都是从数据库取出，生成一个 BO 或者是 DTO，我们这里
 * 使用一个静态的值来做代表；Mail 类是一封邮件类，发送机发送的就是这个类，我们先来看看我们的程序：
 */
 public class AdvTemplate {
 
 /**
 * 广告信名称
 */
 private String advSubject = "XX银行国庆信用卡抽奖活动";
 
 /**
 * 广告信内容
 */
 private String advContent = "国庆抽奖活动通知：只要刷卡就送你1百万！....";
 
 /**
 * 取得广告信的名称
 *
 * @return 广告信的名称
 */
 public String getAdvSubject() {
 return this.advSubject;
 }
 
 /**
 * 取得广告信的内容
 *
 * @return 广告信的内容
 */
 public String getAdvContent() {
 return this.advContent;
 }
 }

package com.iot.practice.designpattern.prototype;
 
 import lombok.Data;
 
 /**
 * Mail 此类用于：
 * @author：hujm
 * @date：2021年02月06日 10:05
 * @remark：Mail 就是一个业务对象，我们再来看业务场景类是怎么调用的：
 */
 @Data
 public class Mail implements Cloneable {
 
 /**
 * 收件人
 */
 private String receiver;
 
 /**
 * 邮件名称
 */
 private String subject;
 
 /**
 * 称谓
 */
 private String appellation;
 
 /**
 * 邮件内容
 */
 private String context;
 
 /**
 * 邮件的尾部，一般都是加上“XXX版权所有”等信息
 */
 private String tail;
 
 /**
 * 构造函数
 */
 public Mail(AdvTemplate advTemplate) {
 this.context = advTemplate.getAdvContent();
 this.subject = advTemplate.getAdvSubject();
 }
 
 /**
 * 增加了一个 Cloneable 接口， Mail 实现了这个接口，在 Mail 类中重写了 clone()方法，我们来看 Mail类的改变：
 *
 * 在 clone()方法上增加了一个注解@Override，没有继承一个类为什么可以重写呢？在 Java 中所有类的
 * 老祖宗是谁？对嘛，Object 类，每个类默认都是继承了这个类，所以这个用上重写是非常正确的。
 *
 * @return Mail
 */
 @Override
 public Mail clone() {
 
 Mail mail = null;
 try {
 mail = (Mail) super.clone();
 } catch (CloneNotSupportedException e) {
 e.printStackTrace();
 }
 
 return mail;
 }
 }

## 2.2 浅拷贝代码 ##

package com.iot.practice.designpattern.prototype.shallowcopy;
 
 /**
 * ShallowCopyClient 此类用于：
 * @author：hujm
 * @date：2021年02月06日 14:57
 * @remark：
 * 在 Thing 类中增加一个私有变量 arrayLis，类型为 ArrayList,然后通过 setValue 和 getValue 分别进
 * 行设置和取值，我们来看场景类：
 * 
 */
 public class ShallowCopyClient {
 
 public static void main(String[] args) {
 
 // 产生一个对象
 ShallowCopy shallowCopy = new ShallowCopy();
 // 设置一个值
 shallowCopy.setValue("张三");
 
 // 拷贝一个对象
 ShallowCopy cloneShallowCopy = shallowCopy.clone();
 cloneShallowCopy.setValue("李四");
 
 // 运行的结果是：[张三, 李四]
 System.out.println(shallowCopy.getValue());
 
 /**
 * 怎么会有李四呢？是因为 Java 做了一个偷懒的拷贝动作，Object 类提供的方法 clone() 只是拷贝本对象，
 * 其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，
 * 确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一个种非常不安全的方式，在实
 * 际项目中使用还是比较少的。你可能会比较奇怪，为什么在 Mail 那个类中就可以使用使用 String 类型，
 * 而不会产生由浅拷贝带来的问题呢？内部的数组和引用对象才不拷贝，其他的原始类型比如
 * int,long,String(Java 就希望你把 String 认为是基本类型，String 是没有 clone() 方法的)等都会被拷贝的。
 */
 }
 }

package com.iot.practice.designpattern.prototype.shallowcopy;
 
 import java.util.ArrayList;
 
 /**
 * ShallowCopy 此类用于：
 * @author：hujm
 * @date：2021年02月06日 14:52
 * @remark：
 */
 public class ShallowCopy implements Cloneable {
 
 /**
 * 定义一个私有变量
 */
 private ArrayList<String> arrayList = new ArrayList<>();
 
 @Override
 public ShallowCopy clone() {
 
 ShallowCopy shallowCopy = null;
 
 try {
 shallowCopy = (ShallowCopy) super.clone();
 } catch (CloneNotSupportedException e) {
 e.printStackTrace();
 }
 
 return shallowCopy;
 }
 
 /**
 * 取得arrayList的值
 */
 public ArrayList<String> getValue() {
 return this.arrayList;
 }
 
 /**
 * 设置List的值
 *
 * @param value 值
 */
 public void setValue(String value) {
 this.arrayList.add(value);
 }
 }

## 2.3 深拷贝代码 ##

package com.iot.practice.designpattern.prototype.deepcopy;
 
 /**
 * ShallowCopyClient 此类用于：
 * @author：hujm
 * @date：2021年02月06日 14:57
 * @remark：
 * 在 Thing 类中增加一个私有变量 arrayLis，类型为 ArrayList,然后通过 setValue 和 getValue 分别进
 * 行设置和取值，我们来看场景类：
 * 
 */
 public class DeepCopyClient {
 
 public static void main(String[] args) {
 
 // 产生一个对象
 DeepCopy deepCopy = new DeepCopy();
 // 设置一个值
 deepCopy.setValue("张三");
 
 // 拷贝一个对象
 DeepCopy cloneDeepCopy = deepCopy.clone();
 cloneDeepCopy.setValue("李四");
 
 // 运行的结果是：[张三]
 System.out.println(deepCopy.getValue());
 
 /**
 * 这个实现了完全的拷贝，两个对象之间没有任何的瓜葛了，你修改你的，我修改我的，不相互影响，
 * 这种拷贝就叫做深拷贝，深拷贝还有一种实现方式就是通过自己写二进制流来操作对象，然后实现对象的
 * 深拷贝，这个大家有时间自己实现一下。
 * 深拷贝和浅拷贝建议不要混合使用，一个类中某些引用使用深拷贝某些引用使用浅拷贝，这是一种非
 * 常差的设计，特别是是在涉及到类的继承，父类有几个引用的情况就非常的复杂，建议的方案深拷贝和浅
 * 拷贝分开实现
 */
 }
 }

package com.iot.practice.designpattern.prototype.deepcopy;
 
 import java.util.ArrayList;
 
 /**
 * DeepCopy 此类用于：
 * @author：hujm
 * @date：2021年02月06日 15:03
 * @remark：
 */
 public class DeepCopy implements Cloneable {
 
 /**
 * 定义一个私有变量
 */
 private ArrayList<String> arrayList = new ArrayList<>();
 
 @Override
 public DeepCopy clone() {
 DeepCopy deepCopy = null;
 
 try {
 deepCopy = (DeepCopy) super.clone();
 this.arrayList = (ArrayList<String>) this.arrayList.clone();
 } catch (CloneNotSupportedException e) {
 e.printStackTrace();
 }
 
 return deepCopy;
 }
 
 /**
 * 设置值
 */
 public void setValue(String value) {
 this.arrayList.add(value);
 }
 
 /**
 * 取值
 */
 public ArrayList<String> getValue() {
 return this.arrayList;
 }
 }

# 三、原码分析 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 2][]

完结！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70]: /images/20221024/a1859707f57442f289909d6568053734.png
[https_gitee.com_no8g_java-design-patterns]: https://gitee.com/no8g/java-design-patterns
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 1]: /images/20221024/681da798d4ae4e1ca33b554dd18e2c2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 2]: /images/20221024/6da69ee688214399a1c181799ba9490d.png