当前位置：移动技术网 > IT编程>软件设计>设计模式 > 创建型设计模式 -- 原型模式

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

2019年08月14日 | 移动技术网IT编程 | 我要评论

一、小案例分析

1、功能需求：

　　现有一个员工，姓名为rick，年龄22，id为193211，如何创建10个完全相同的对象。

2、小菜鸡的答案：

（1）直接new 10个对象就完了。
（2）代码实现：

package prototype.pattern;

public class demo {
    public static void main(string[] args) {
        employee employee = new employee("tom", 22, 193211);
        employee employee1 = new employee("tom", 22, 193211);
        employee employee2 = new employee("tom", 22, 193211);
        employee employee3 = new employee("tom", 22, 193211);
        employee employee4 = new employee("tom", 22, 193211);
        employee employee5 = new employee("tom", 22, 193211);
        employee employee6 = new employee("tom", 22, 193211);
        employee employee7 = new employee("tom", 22, 193211);
        employee employee8 = new employee("tom", 22, 193211);
        employee employee9 = new employee("tom", 22, 193211);
        system.out.println(employee);
        system.out.println(employee1);
        system.out.println(employee2);
        system.out.println(employee3);
        system.out.println(employee4);
        system.out.println(employee5);
        system.out.println(employee6);
        system.out.println(employee7);
        system.out.println(employee8);
        system.out.println(employee9);
    }
}

class employee {
    private string name;
    private int age;
    private long id;

    public employee(string name, int age, long id) {
        super();
        this.name = name;
        this.age = age;
        this.id = id;
    }

    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;
    }

    public long getid() {
        return id;
    }

    public void setid(long id) {
        id = id;
    }

    @override
    public string tostring() {
        return "employee [name=" + name + ", age=" + age + ", id=" + id + "]";
    }
}

（3）代码分析：
　　容易理解，好操作。但是每次都是初始化对象，而不是动态获得对象，不够灵活，效率低。

二、原型模式

1、什么是原型模式

　　指的是用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。是一种创建模式，允许一个对象去创建另一个可定制的对象且不用知道如何创建的细节。

2、如何实现（影分身之术）

　　将一个原型对象传给发动创建的对象，此对象通过请求原型对象拷贝自身来进行创建，即调用clone方法。

3、clone方法、浅拷贝、深拷贝

　　可以参照如下地址：
　　　　https://www.cnblogs.com/l-y-h/p/10906499.html#_label1
注：
　　上面链接中只讲述了通过clone方法实现深拷贝（所有涉及到的类均要实现cloneable接口）。
　　也可以使用序列化的方式实现深拷贝（推荐，所有涉及到的类均要实现serializable接口）。

package prototype.pattern;

import java.io.bytearrayinputstream;
import java.io.bytearrayoutputstream;
import java.io.ioexception;
import java.io.objectinputstream;
import java.io.objectoutputstream;
import java.io.serializable;

public class demo {
    public static void main(string[] args) {
        employee employee = new employee("tom", 22, 193211);
        employee employee2 = (employee) employee.deepclone();
        system.out.println(employee);
        system.out.println(employee2);
    }
}

// 此处若不实现serializable 接口，会抛出java.lang.nullpointerexception异常。
class person implements serializable {
    private string name;
    private int age;

    public person(string name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @override
    public string tostring() {
        return "person [name=" + name + ", age=" + age + "]";
    }
}

class employee implements serializable {
    private string name;
    private int age;
    private long id;
    private person people = new person("jarry", 20);

    public employee(string name, int age, long id) {
        super();
        this.name = name;
        this.age = age;
        this.id = id;
    }

    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;
    }

    public long getid() {
        return id;
    }

    public void setid(long id) {
        id = id;
    }

    @override
    public string tostring() {
        return "employee [name=" + name + ", age=" + age + ", id=" + id + "]";
    }

    /**
     * 使用序列化的方式实现深拷贝
     * 
     * @return
     */
    public object deepclone() {
        bytearrayoutputstream baos = null;
        objectoutputstream oos = null;
        bytearrayinputstream bias = null;
        objectinputstream ois = null;
        try {
            // 序列化
            baos = new bytearrayoutputstream();
            oos = new objectoutputstream(baos);
            oos.writeobject(this); // 将当前对象以对象流的方式输出

            // 反序列化
            bias = new bytearrayinputstream(baos.tobytearray());
            ois = new objectinputstream(bias);
            employee employee = (employee) ois.readobject();
            return employee;
        } catch (exception e) {
            system.out.println(e.getmessage());
            return null;
        } finally {
            try {
                baos.close();
                oos.close();
                bias.close();
                ois.close();
            } catch (ioexception e) {
                system.out.println(e.getmessage());
            }
        }
    }
}

4、使用原型模式实现上例

（1）使原型类实现 cloneable 接口（只有实现该接口，才能重写clone方法）。
（2）调用原型对象自身的clone方法实现拷贝。
（3）代码实现：

package prototype.pattern;

public class demo {
    public static void main(string[] args) {
        employee employee = new employee("tom", 22, 193211);
        employee employee1 = (employee) employee.clone();
        employee employee2 = (employee) employee.clone();
        employee employee3 = (employee) employee.clone();
        employee employee4 = (employee) employee.clone();
        employee employee5 = (employee) employee.clone();
        employee employee6 = (employee) employee.clone();
        employee employee7 = (employee) employee.clone();
        employee employee8 = (employee) employee.clone();
        employee employee9 = (employee) employee.clone();
        system.out.println(employee);
        system.out.println(employee1);
        system.out.println(employee2);
        system.out.println(employee3);
        system.out.println(employee4);
        system.out.println(employee5);
        system.out.println(employee6);
        system.out.println(employee7);
        system.out.println(employee8);
        system.out.println(employee9);
    }
}

class employee implements cloneable {
    private string name;
    private int age;
    private long id;

    public employee(string name, int age, long id) {
        super();
        this.name = name;
        this.age = age;
        this.id = id;
    }

    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;
    }

    public long getid() {
        return id;
    }

    public void setid(long id) {
        id = id;
    }

    @override
    public string tostring() {
        return "employee [name=" + name + ", age=" + age + ", id=" + id + "]";
    }

    @override
    protected object clone() {
        employee employee = null;
        try {
            employee = (employee) super.clone();
        } catch (clonenotsupportedexception e) {
            system.out.println(e.getmessage());
        }
        return employee;
    }
}

（3）代码分析：
　　让程序有更好的扩展性与效率，当修改某个原型对象时，其余clone后的对象均会被修改。
（4）uml图：

5、使用原型模式的优缺点

（1）优点：当创建新的对象比较复杂时，使用原型模式可以简化创建流程、且提高创建的效率。不需要重新new对象，而是动态的获取运行中的对象。
（2）缺点：当实现深拷贝的clone方法时，需要给所有涉及到的类加个clone方法，可能会违反开闭原则。

三、spring中原型模式分析

1、bean的创建

　　在创建bean的时候，可以选择是单例模式（同一对象）还是原型模式（不同对象）。

2、部分源码：（稍后整理）

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

安卓实战之如何快速搭建app架构

前言最近公司的另一个项目又要立项了，作为公司的唯一安卓工程师任务来了（新来的移动端的老大说项目还是主要你负责，我... [阅读全文]
荐厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略

前言根据百度指数搜索“中台”，可以发现中台这个概念从2019年5月21日起突然火了起来，并持续火爆。如果对201... [阅读全文]
Rabbit MQ 集群架构下的几种模式

Rabbit MQ 集群架构下的几种模式1、主备模式1、主备模式主备模式 :实现 RabbitMQ 的高可用集群... [阅读全文]
设计模式（一）之七大原则

文章目录单一职责原则接口隔离原则依赖倒转原则里氏替换原则开闭原则迪米特法则合成复用原则单一职责原则一个类只负责一... [阅读全文]
设计模式之中介者

一.简介现实生活中常有许多对象存在复杂的交互关系，这种关系常是“网状结构”，把这种“网状结构”改为“星形结构”的... [阅读全文]
FlowableException: Error initialising dmn data model报错问题

flowable war包启动失败,报错Caused by: org.flowable.common.engin... [阅读全文]
荐深入理解单例模式

深入理解单例模式单例模式是应用最广的设计模式之一，也是程序员最熟悉的一个设计模式，使用单例模式的类必须保证只能有... [阅读全文]
荐设计模式之单例模式（通俗易懂，超详细）

1 什么是单例模式单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个... [阅读全文]
接口

接口（interface）接口的基础语法：接口介绍：接口也是一种引用数据类型。编译之后也是一个class字节码... [阅读全文]
设计模式--单例模式

设计模式–单例模式单例模式1.作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。2.优点：由于单... [阅读全文]

网友评论


验证码：