设计模式-原型模式

1 原型模式介绍

原型模式(Prototype)是一个创建型的模式，原型模式是有一个共有信息的样板实例，然后拷贝这个样板实例，而复制后的实例就是所谓的“原型”，这个原型是可以修改的。原型模式多用于创建复杂的或者构造耗时的实例，因为这种情况下， 复制一个已经存在的实例可以使程序运行更高效。

2 原型模式定义

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

3 原型模式UML类图

在原型模式中有如下角色：

• Client：客户端角色。
• Prototype：抽象原型角色，抽象类或者接口，用来声明clone方法。
• ConcretePrototype：具体的原型类，是客户端角色使用的对象，即被复制的对象。

4 原型模式的使用场景

1. 类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等。通过原型拷贝避免这些消耗。
2. 通过new产生一个独享需要非常频繁的数据准备或访问权限。
3. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。

5 原型模式使用示例

下面我们模拟一个发送短信的例子，来看下原型模式的简单使用: 其中Message类扮演的是ConcretePrototype，Cloneable就是Prototype 具体的原型类：

public class Message implements Cloneable{
    private String name;
    private double money;

    public Message() {
        System.out.println("执行构造函数Message");
    }

    public void setMessage(String name, double money) {
        this.name = name;
        this.money = money;
    }

    @NonNull
    @Override
    public Message clone() {
        Message message = null;
        try {
            message = (Message) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return message;
    }

    public void sendMessage(){
        System.out.println(name +"您好：您今天消费了"+money+"元");
    }
}

Message 类实现了Cloneable接口，它是一个标识接口，表示这个对象是可拷贝的，只要重写clone方法就可以实现拷贝。

这里需要注意的是clone方法并不是Cloneable接口中的，而是Object中的方法。

下面我们看下客户端实现：

public class MbClient {
    public static void main(String[] args){
        Message message = new Message();
        message.setMessage("张三",100);

        Message message1 = message.clone();
        message1.setMessage("李四",200);

        Message message2 = message.clone();
        message2.setMessage("王五",300);

        message.sendMessage();
        message1.sendMessage();
        message2.sendMessage();
    }
}

我们可以看到李四和王五的消息是通过clone方法克隆的，而clone方法是不会执行构造函数的。输出的结果如下：

//执行构造函数Message
//张三您好：您今天消费了100.0元
//李四您好：您今天消费了200.0元
//王五您好：您今天消费了300.0元

如果Message 类没有实现了Cloneable接口，就去直接调用clone方法，就会抛出异常。输出结果如下：

执行构造函数Message
java.lang.CloneNotSupportedException: com.monkey.myapplication.mbdemo.Message
	at java.lang.Object.clone(Native Method)
	at com.monkey.myapplication.mbdemo.Message.clone(Message.java:27)
	at com.monkey.myapplication.mbdemo.MbClient.main(MbClient.java:13)
Exception in thread "main" java.lang.NullPointerException
	at com.monkey.myapplication.mbdemo.MbClient.main(MbClient.java:14)

6 浅拷贝和深拷贝

由于Object类提供的clone方法，不会拷贝对象中的内部数组和引用对象，所以就有了浅拷贝和深拷贝。

6.1 浅拷贝

我们继续使用发送短信的例子来看下浅拷贝，在Message类中有一个消费明细对象。

public class Message implements Cloneable{
    private String name; //姓名
    private ExpenseDetail detail;//消费明细

    public Message() {
        System.out.println("执行构造函数Message");
        detail = new ExpenseDetail();
    }

    public void setMessage(String name, String type,double money) {
        this.name = name;
        this.detail.setType(type);
        this.detail.setMoney(money);
    }

    @NonNull
    @Override
    public Message clone() {
        Message message = null;
        try {
            message = (Message) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return message;
    }

    public void sendMessage(){
        System.out.println(name +"您好：您今天"+detail.getType()+"消费了"+detail.getMoney()+"元");
    }
}

消费明细类

public class ExpenseDetail{
    private String type;
    private double money;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

客户端类

public class MbClient {
    public static void main(String[] args){
        Message message = new Message();
        message.setMessage("张三","吃饭",10);

        Message message1 = message.clone();
        message1.setMessage("李四","看电影",50);

        Message message2 = message.clone();
        message2.setMessage("王五","买书",100);

        message.sendMessage();
        message1.sendMessage();
        message2.sendMessage();
    }
}

输出的结果如下：

执行构造函数Message
张三您好：您今天买书消费了100.0元
李四您好：您今天买书消费了100.0元
王五您好：您今天买书消费了100.0元

我们可以看到所有人的消费明细居然都一样，这是因为Object类提供的clone方法，不会拷贝对象中的内部数组和引用对象，导致它们仍旧指向原来对象的内部元素地址，这种拷贝叫做浅拷贝。 由此而导致最后一次的值会覆盖前一次的值。

6.2 深拷贝

public class Message implements Cloneable{
    ...
    
    @NonNull
    @Override
    public Message clone() {
        Message message = null;
        try {
            message = (Message) super.clone();
            message.detail = this.detail.clone();//拷贝消费明细
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return message;
    }
    ...

}

public class ExpenseDetail implements Cloneable{
    private String type;
    private double money;
    ...
    @NonNull
    @Override
    protected ExpenseDetail clone(){

        ExpenseDetail detail = null;
        try {
            detail = (ExpenseDetail) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return detail;
    }
}

使用浅拷贝的客户端代码再次执行后，输出的结果如下：

执行构造函数Message
张三您好：您今天吃饭消费了10.0元
李四您好：您今天看电影消费了50.0元
王五您好：您今天买书消费了100.0元

拷贝Message对象的同时，也将它内部的引用对象ExpenseDetail进行拷贝，使得每个拷贝的对象之间无任何关联，都指向了自身对应的ExpenseDetail，这种拷贝就是深拷贝。

7 总结

原型模式本质上就是对象拷贝。使用原型模式可以解决构建复杂对象的资源消耗问题，能够在某些场景下提升创建对象的效率，还有一个特点就是保护性拷贝，如果我们操作时，不会对原有的对象造成影响。

优点： 原型模式是在内存中二进制流的拷贝，要比new一个对象的性能要好，特别是需要生产大量对象时。

缺点： 直接在内存中拷贝，构造函数是不会执行的，这样就减少了约束，既是优点也是缺点，在实际开发当中应注意这个问题。