6、设计模式-创建型模式-原型模式

原型模式

在使用原型模式时，我们需要首先创建一个原型对象，再通过复制这个原型对象来创建更多
同类型的对象。

定义：

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

工作原理：

将一个原型对象传给那个要发动创建的对象，这个要发动创建
的对象通过请求原型对象拷贝自己来实现创建过程。

由于在软件系统中我们经常会遇到需要
创建多个相同或者相似对象的情况，因此原型模式在真实开发中的使用频率还是非常高的。

原型模式是一种“另类”的创建型模式，创建克隆对象的工厂就是原型类自身，工厂方法由克隆
方法来实现。

注意：

通过克隆方法创建的对象是全新的对象

在内存中拥有最新的地址

通常对克隆所产生的对象进行修改对原型对象不会造成任何影响

每一个克隆对象都是通过相互独立的

通过不同方式修改可以得到一系列相似但不完全相同的对象

图示结构：

角色：

Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，可以
是抽象类也可以是接口，甚至还可以是具体实现类。

ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中
返回自己的一个克隆对象。

Client（客户类）：让一个原型对象克隆自身从而创建一个新的对象，在客户类中只需要直

接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到
多个相同的对象。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体
原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。

核心：

如何实现克隆方法

1、通用的实现方法

通用的克隆实现方法是在具体原型类的克隆方法中实例化一个与自身类型相同的对象并将其
返回，并将相关的参数传入新创建的对象中，保证它们的成员属性相同。

class ConcretePrototype implements Prototype
{
　　private String attr; //成员属性

　　public void setAttr(String attr)
　　{
　　　　this.attr = attr;
　　}

　　public String getAttr()
　　{
　　　　return this.attr;
　　}

　　public Prototype clone() //克隆方法
　　{
　　　　Prototype prototype = new ConcretePrototype(); //创建新对象
　　　　prototype.setAttr(this.attr);
　　　　return prototype;
　　}
}

在客户端进行调用clone()方法即可

Prototype obj1 = new ConcretePrototype();
obj1.setAttr("Sunny");
Prototype obj2 = obj1.clone();

这种方法可作为原型模式的通用实现，它与编程语言特性无关，任何面向对象语言都可以使
用这种形式来实现对原型的克隆。

2、Java语言提供的clone()方法

所有的Java类都继承自java.lang.Object。

Object类提供一个clone()方法，可以将一个Java对象复制一份。

因此在Java中可以直接使用Object提供的clone()方
法来实现对象的克隆，Java语言中的原型模式实现很简单。

需要注意的是能够实现克隆的Java类必须实现一个标识接口Cloneable

表示这个Java类支持被复制。

如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常。

class ConcretePrototype implements Cloneable
{
　　……
　　public Prototype clone()
　　{
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("Not support cloneable");
　　　　}
　　　　return (Prototype )object;
　　}
　　……
}

Prototype obj1 = new ConcretePrototype();
Prototype obj2 = obj1.clone();

一般而言，Java语言中的clone()满足：

(1) 对任何对象x，都有x.clone() != x，即克隆对象与原型对象不是同一个对象；
(2) 对任何对象x，都有x.clone().getClass() == x.getClass()，即克隆对象与原型对象的类型一样；

(3) 如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立

为了获取对象的一份拷贝，可以直接使用Object类的clone()方法：

(1) 在派生类中覆盖基类的clone()方法，并声明为public；
(2) 在派生类的clone()方法中，调用super.clone()；
(3)派生类需实现Cloneable接口。

此时，Object类相当于抽象原型类，所有实现了Cloneable接口的类相当于具体原型类。

事例：

对于OA系统进行日常工作办理

但在使用过程中，越来越多的人对工作周报的创建和编写模块产生了抱怨。

用户只能通过重新输入或不断复制粘贴来填写重复的周报内
容，极大降低了工作效率，浪费宝贵的时间。

思想：

(1)除了允许用户创建新周报外，还允许用户将创建好的周报保存为模板；
(2)用户在再次创建周报时，可以创建全新的周报，还可以选择合适的模板复制生成一份相同
的周报，然后对新生成的周报根据实际情况进行修改，产生新的周报。

解决方案：

public class WeekLog implements Cloneable {

    private String name;
    private String  data;
    private String content;

    public String getName() {
        return name;
    }

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

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    //克隆方法clone()，此处使用Java语言提供的克隆机制
    public WeekLog clone(){
        Object obj = null;

        try {
            obj = super.clone();
            return (WeekLog) obj;
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
            System.out.println("不支持复制");
            return null;
        }
    }
}

public class client {

    public static void main(String[] args) {
        WeekLog log = new WeekLog();
        log.setName("MrChengs");
        log.setData("2019/5/19");
        log.setContent("此时的任务是原型模式");

        System.out.println("****周报****");
        System.out.println("周次：" + log.getData());
        System.out.println("姓名：" + log.getName());
        System.out.println("内容：" + log.getContent());
        System.out.println("--------------------------------");

        //进行复制
        WeekLog log_new;
        log_new = log.clone();
        log_new.setData("2019/5/20");
        System.out.println("****周报****");
        System.out.println("周次：" + log_new.getData());
        System.out.println("姓名：" + log_new.getName());
        System.out.println("内容：" + log_new.getContent());

    }

}

此时的结构：

OA系统支持工作周报的快速克隆，极大提高了工作周报的编写效率

如果此时的附件需要带一些文件（附件）

浅克隆：

如果原型对象的成员变量是值类型，将复制一份给克隆对象；

如果原型对象的
成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆
对象的成员变量指向相同的内存地址。

在浅克隆中，当对象被复制时只复制它本
身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制

 

//附件
public class Attachment {
    private String  name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void downLoad(){
        System.out.println("下载附件：" + name);
    }
}

public class WeekLog implements Cloneable {

    private String name;
    private String  data;
    private String content;
    private Attachment attachment;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public Attachment getAttachment() {
        return attachment;
    }
    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }
    //克隆方法clone()，此处使用Java语言提供的克隆机制
    public WeekLog clone(){
        Object obj = null;

        try {
            obj = super.clone();
            return (WeekLog) obj;
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
            System.out.println("不支持复制");
            return null;
        }
    }
}

public static void main(String[] args) {

        Attachment attachment = new Attachment();
        attachment.setName("本周日报");

        WeekLog log = new WeekLog();
        log.setName("MrChengs");
        log.setData("2019/5/19");
        log.setAttachment(attachment);
        log.setContent("此时的任务是原型模式");

        System.out.println("****周报****");
        System.out.println("周次：" + log.getData());
        System.out.println("姓名：" + log.getName());
        System.out.println("内容：" + log.getContent());
        System.out.println("附件：" + log.getAttachment());
        System.out.println("--------------------------------");

        //进行复制
        WeekLog log_new;
        log_new = log.clone();
        log_new.setData("2019/5/20");
        System.out.println("****周报****");
        System.out.println("周次：" + log_new.getData());
        System.out.println("姓名：" + log_new.getName());
        System.out.println("内容：" + log_new.getContent());
        System.out.println("附件：" + log_new.getAttachment());

        System.out.println("周报是否相同：" + (log == log_new));
        System.out.println("附件是否相同" + (log.getAttachment() == log_new.getAttachment()));
    }

此时结构图：

由于使用的是浅克隆技术，因此工作周报对象复制成功，通过“==”比较原型对象和克隆对象
的内存地址时输出false；但是比较附件对象的内存地址时输出true，说明它们在内存中是同一
个对象。

深克隆：

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，
深克隆将原型对象的所有引用对象也复制一份给克隆对象。

在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制

 

如果需要实现深克隆，可以通过序列化(Serialization)等方式来实现。

序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。

通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此
通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。

需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

//附件
public class Attachment implements Serializable {
    private String  name;

    public String getName() {
        return name;
    }

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

    public void downLoad(){
        System.out.println("下载附件：" + name);
    }
}

public class WeekLog implements Serializable {

    private String name;
    private String  data;
    private String content;
    private Attachment attachment;

    //克隆方法clone()，此处使用Java语言提供的克隆机制
    public WeekLog dowmclone() throws  Exception{
        //将对象写入流
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(this);

        //将对象从流中取出
        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(in);

        return (WeekLog) ois.readObject();
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public Attachment getAttachment() {
        return attachment;
    }
    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }


}

 public static void main(String[] args) {

        WeekLog log,log_new = null;
        Attachment attachment = new Attachment();
        attachment.setName("月报");

        log = new WeekLog();
        log.setAttachment(attachment);
        log.setName("MrChengs");
        log.setData("2019/5/19");
        log.setContent("周报");

        try {
            log_new = log.dowmclone();//深克隆
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("周报相同：" + (log == log_new));
        System.out.println("附件相同:" + (log.getAttachment() == log_new.getAttachment()) );
    }

 

 此时的结构图：

使用了深克隆技术，附件对象也得以复制，因此用“==”比较原型
对象的附件和克隆对象的附件时输出结果均为false。

深克隆技术实现了原型对象和克隆对象的

完全独立，对任意克隆对象的修改都不会给其他对象产生影响，是一种更为理想的克隆实现
方式

 补充：

Java语言提供的Cloneable接口和Serializable接口的代码非常简单，它们都是空接口，这种
空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的
实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。

原型管理器的引入和实现

原型管理器是将多个原型对象存储在一个集合中供客户端使用，它是一个
专门负责克隆对象的工厂，其中定义了一个集合用于存储原型对象，如果需要某个原型对象
的一个克隆，可以通过复制集合中对应的原型对象来获得。在原型管理器中针对抽象原型类
进行编程，以便扩展。

//抽象公文接口，也可定义为抽象类，提供clone()方法的实现，将业务方法声明为抽象方法
interface OfficialDocument extends Cloneable{
    public OfficialDocument clone();
    public void  display();
}

public class FAR implements  OfficialDocument {
    @Override
    public OfficialDocument clone() {

        OfficialDocument officialDocument = null;
        try {
            officialDocument = (OfficialDocument) super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return officialDocument;
    }

    @Override
    public void display() {
        System.out.println("可行性分析");
    }
}

public class SRS implements   OfficialDocument {
    @Override
    public OfficialDocument clone() {

        OfficialDocument officialDocument = null;
        try {
            officialDocument = (OfficialDocument) super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return officialDocument;
    }

    @Override
    public void display() {
        System.out.println("规格说明书");
    }
}

 原型管理器

public class PrototypeManager {
    //定义Hashtable用来存储原型对象
    private Hashtable hashtable = new Hashtable();
    private static PrototypeManager prototypeManager = new PrototypeManager();
    private PrototypeManager(){
        hashtable.put("far",new FAR());
        hashtable.put("srs",new SRS());
    }

    //增加新的对象
    public  void  addOffiaclDocument(String key,OfficialDocument off){
        hashtable.put(key,off);
    }

    //克隆获取新的对象
    public OfficialDocument getOfficialDocument(String key){
        return ((OfficialDocument)hashtable.get(key)).clone();
    }
    public static PrototypeManager getPrototypeManager(){
        return  prototypeManager;
    }
}

public class client {
    public static void main(String[] args) {

        PrototypeManager pm = PrototypeManager.getPrototypeManager();

        OfficialDocument off1,off2,off3,off4;

        off1 = pm.getOfficialDocument("far");
        off1.display();
        off2 = pm.getOfficialDocument("far");
        off2.display();
        System.out.println(off1 == off2);

        off3 = pm.getOfficialDocument("srs");
        off3.display();
        off4 = pm.getOfficialDocument("srs");
        off4.display();
        System.out.println(off3 == off4);
    }
}

 

此时的结构图：

在PrototypeManager中定义了一个Hashtable类型的集合对象，使用“键值对”来存储原型对象，
客户端可以通过Key（如“far”或“srs”）来获取对应原型对象的克隆对象。

PrototypeManager类提供了类似工厂方法的getOfficialDocument()方法用于返回一个克隆对象。

优点：

(1) 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过复制一个
已有实例可以提高新实例的创建效率。

(2) 扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编
程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。

(3) 原型模式提供了简化的创建结构，工厂方法模式常常需要有一个与产品类等级结构相同的
工厂等级结构，而原型模式就不需要这样，原型模式中产品的复制是通过封装在原型类中的
克隆方法实现的，无须专门的工厂类来创建产品。

(4) 可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起
来，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。

缺点：

(1) 需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进
行改造时，需要修改源代码，违背了“开闭原则”。

(2) 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了
实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦。

适用场景：

(1) 创建新对象成本较大（如初始化需要占用较长的时间，占用太多的CPU资源或网络资
源），新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对
其成员变量稍作修改。

(2) 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时，可
以使用原型模式配合备忘录模式来实现。

(3) 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的
几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方
便。