原型模式（Prototype Pattern）

🍀以下内容同步发布在我的个人博客https://www.lvjguo.top😊

1 介绍

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

特点：不需要知道任何创建的细节，不调用构造函数

类型：创建型

适用场景：

• 类初始化消耗较多资源
• new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）
• 构造函数比较复杂
• 循环体中生产大量对象时

优点：

• 比直接new一个对象性能高
• 简化创建过程

缺点：

• 必须配备克隆方法，需要对类的功能进行通盘考虑
• 对克隆复杂对象或对克隆出的对象进行复杂改造时，容易引入风险
• 深拷贝、浅拷贝要运用得当

UML类图：

原型模式主要用于对象的复制，它的核心类Prototype需要具备以下两个条件：

1. 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
2. 重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。

2 示例

考虑这样一个业务场景，现在阿里云做活动，云服务器大降价，他需要把这个活动通过邮件的方式通知他的用户，但是，如果每封邮件的创建是非常繁琐的，那我们该怎么来发邮件呢？

具体原型角色：Mail

@Data
public class Mail implements Cloneable{
    private String name;   //邮件接收人
    private String emailAddress;   //邮件地址
    private String content;  //邮件内容
    
    @Override
    public String toString() {
        return "Mail{" +
                "name='" + name + '\'' +
                ", emailAddress='" + emailAddress + '\'' +
                ", content='" + content + '\'' +
                '}'+super.toString();
    }
    
    public Mail(){
        System.out.println("Mail Class Constructor");
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("clone mail object");
        return super.clone();
    }
}

客户角色：MailUtil发送邮件

public class MailUtil {
    //发送邮件
    public static void sendMail(Mail mail){
        String outputContent = "向{0}同学,邮件地址:{1},邮件内容:{2}，发送邮件成功";
        System.out.println(MessageFormat.format(outputContent,mail.getName(),mail.getEmailAddress(),mail.getContent()));
    }
    
    //
    public static void saveOriginMailRecord(Mail mail){
        System.out.println("存储originMail记录,originMail:"+mail.getContent());
    }
}

客户端测试类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Mail mail = new Mail();
        mail.setContent("初始化模板");
        System.out.println("初始化mail:"+mail);
        for(int i = 0;i < 10;i++){
            //克隆邮件
            Mail mailTemp = (Mail) mail.clone();
            mailTemp.setName("姓名"+i);
            mailTemp.setEmailAddress(i+"@qq.com");
            mailTemp.setContent("阿里云云服务器降价啦，快来购买！");
            MailUtil.sendMail(mailTemp);
            System.out.println("克隆的mailTemp:"+mailTemp);
        }
        MailUtil.saveOriginMailRecord(mail);
    }
}

运行结果：

说到克隆，我们需要注意一下深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

@Data
public class Pig implements Cloneable{
    private String name;
    private Date birthday;

    public Pig(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Pig pig = (Pig)super.clone();

        //深克隆
        pig.birthday = (Date) pig.birthday.clone();
        return pig;
    }
}

3 原型与单例模式

• 原型模式 : 原型模式的核心是不调用构造函数 , 使用 clone 方法在内存中克隆对象

• 单例模式 : 单例模式的核心是私有化构造函数 , 控制外部用户 , 不能随意调用构造函数创建对象

此处二者就出现了矛盾 , 如果单例类 , 实现了 Cloneable 接口 , 那么该类就可以调用 clone 方法创建另外的实例对象 , 因此原型模式破坏了单例模式 。

解决方案 :

1. 不实现 Cloneable 接口 : 单例模式中不要实现 Cloneable 接口 , 不提供内存拷贝功能
2. clone 中调用单例 : 如果必须实现 Cloneable 接口 , 那么在重写的 clone 方法中 , 调用获取单例类的方法 , 不要进行内存对象拷贝创建新的实例对象

4 使用典范

• ArrayList类

/**
 * Returns a shallow copy of this <tt>ArrayList</tt> instance.  (The
 * elements themselves are not copied.)
 *
 * @return a clone of this <tt>ArrayList</tt> instance
 */
public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();//克隆一个ArrayList
        //将原型中的数据拷贝到新的ArrayList中
        v.elementData = Arrays.copyOf(elementData, size);
        //修改次数改为0
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}