腾讯云

文章/答案/技术大牛

发布

社区首页 >专栏 >【设计模式自习室】原型模式

【设计模式自习室】原型模式

蛮三刀酱

发布于 2019-12-30 10:00:08

43700

代码可运行

文章被收录于专栏：蛮三刀的后端开发专栏蛮三刀的后端开发专栏

运行总次数：0

代码可运行

前言

《设计模式自习室》系列，顾名思义，本系列文章带你温习常见的设计模式。主要内容有：

该设计模式的详细介绍，包括：
- 引子，意图（大白话解释）
- 类图，时序图（理论规范）
该模式的代码示例：熟悉该模式的代码长什么样子
该模式的优缺点：不可以滥用模式
该模式的实际使用案例：了解它在哪些重要的源码中出现过

该系列会逐步更新于我的博客和公众号（博客见文章底部）

也希望各位观众老爷能够关注我的个人公众号：后端技术漫谈，不会错过精彩好看的文章。

系列文章回顾

原型模式 Prototype

引子

还记得深克隆和浅克隆的区别吗？其实这里说的克隆，就是原型模式。

原型模式要求对象实现一个可以克隆自身的接口(类型)。这样一来，通过原型实例创建新的对象。

原型模式也属于创建型模式。

意图

原型模式有两种表现形式：

简单形式
登记形式

他们的区别在于：第二种登记模式中，多了一个原型管理器(PrototypeManager)角色，该角色的作用是：创建具体原型类的对象，并记录每一个被创建的对象。

如果需要创建的原型对象数目较少而且比较固定的话，可以采取简单形式。在这种情况下，原型对象的引用可以由客户端自己保存。

否则，你可以使用登记形式。原型管理器的作用:

在登记形式下，客户端不保存对原型对象的引用，这个任务被交给原型管理器角色。在克隆一个对象之前，客户端可以查看管理员对象是否已经有一个满足要求的原型对象。如果有，可以从原型管理器角色中取得这个对象引用；如果没有，客户端就需要自行复制此原型对象。

类图

简单形式

客户(Client)：客户类提出创建对象的请求；
抽象原型(Prototype)：这是一个抽象角色，通常是一个Java接口或者抽象类。此角色定义了的具体原型类所需的实现的方法。
具体原型(Concrete Prototype)：此角色需要实现抽象原型角色要求的克隆相关的接口。

登记形式

多出了：

原型管理器(PrototypeManager)：客户端client直接调用原型管理器

时序图

无

使用举例和实际使用场景举例

本文将使用举例和实际使用场景举例放在一起来讨论，是由于原型模式最典型的例子就是Java的深克隆和浅克隆（clone方法），我们直接使用深克隆和浅克隆的代码来熟悉原型模式。

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

（1）对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。
（2）对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。
（3）如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。

在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。

浅复制 clone()

当进浅复制时，clone函数返回的是一个引用，指向的是新的clone出来的对象，此对象与原对象分别占用不同的堆空间。同时，复制出来的对象具有与原对象一致的状态。

此处对象一致的状态是指：复制出的对象与原对象中的属性值完全相等==。

代码示例：

我们复制一本书

1.定义Book类和Author类：

class Author {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

class Book implements Cloneable {

    private String title;
    private int pageNum;
    private Author author;

    public Book clone() {
        Book book = null;
        try {
            book = (Book) super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return book;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

}

2.测试：

package com.qqyumidi;

public class PrototypeTest {

    public static void main(String[] args) {
        Book book1 = new Book();
        Author author = new Author();
        author.setName("corn");
        author.setAge(100);
        book1.setAuthor(author);
        book1.setTitle("好记性不如烂博客");
        book1.setPageNum(230);

        Book book2 = book1.clone();
        
        System.out.println(book1 == book2);  // false
        System.out.println(book1.getPageNum() == book2.getPageNum());   // true
        System.out.println(book1.getTitle() == book2.getTitle());        // true
        System.out.println(book1.getAuthor() == book2.getAuthor());        // true
        
    }
}

虽然复制出来的对象重新在堆上开辟了内存空间，但是，对象中各属性确保持相等。对于基本数据类型很好理解，但对于引用数据类型来说，则意味着此引用类型的属性所指向的对象本身是相同的，并没有重新开辟内存空间存储。换句话说，引用类型的属性所指向的对象并没有复制。

由此，我们将其称之为浅复制。

而当复制后的对象的引用类型的属性所指向的对象也重新得以复制，此时，称之为深复制。

深复制 deepclone()

Java中的深复制一般是通过对象的序列化和反序列化得以实现。序列化时，需要实现Serializable接口。

从输出结果中可以看出，深复制不仅在堆内存上开辟了空间以存储复制出的对象，甚至连对象中的引用类型的属性所指向的对象也得以复制，重新开辟了堆空间存储。

深复制的两种实现方式

在Java语音中，想要实现深度拷贝其实有两种方式：

通过序列化
重写clone，调用子成员的clone方法

代码示例：通过序列化实现深复制

 public  Object deepClone() throws IOException, ClassNotFoundException{
        //将对象写到流里
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        //从流里读回来
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

代码示例：通过重写clone 实现深复制

1.定义Book类和Author类（注意：不仅Book类需要实现Serializable接口，Author同样也需要实现Serializable接口!!）：

class Author implements Serializable{

    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

class Book implements Serializable {

    private String title;
    private int pageNum;
    private Author author;

    public Book deepClone() throws IOException, ClassNotFoundException{
        // 写入当前对象的二进制流 
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);
        
        // 读出二进制流产生的新对象  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return (Book) ois.readObject();
    }
    
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

}

2.测试：

public class PrototypeTest {

    public static void main(String[] args) throws ClassNotFoundException, IOException {
        Book book1 = new Book();
        Author author = new Author();
        author.setName("corn");
        author.setAge(100);
        book1.setAuthor(author);
        book1.setTitle("好记性不如烂博客");
        book1.setPageNum(230);

        Book book2 = book1.deepClone();
        
        System.out.println(book1 == book2);  // false
        System.out.println(book1.getPageNum() == book2.getPageNum());   // true
        System.out.println(book1.getTitle() == book2.getTitle());        // false
        System.out.println(book1.getAuthor() == book2.getAuthor());        // false
        
    }
}