AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【设计模式】-创建型模式-第2章第4讲-【原型模式】

2022-10-27 130
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【设计模式】-创建型模式-第2章第4讲-【原型模式】

目录

1、原型模式（Prototype Pattern）概念

2、浅拷贝与深拷贝

2.1、概念

2.2、Java 中的深浅拷贝

浅拷贝：

深拷贝：

实例

浅拷贝

深拷贝的两种实现方式

方式一

方式二

3、原型模式的优缺点

4、 结尾

1、原型模式（Prototype Pattern）概念

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

原型模式看似复杂，实际上它只是一种克隆对象的方法。现在实例化对象操作并不特别耗费性能，那为啥还需要对象克隆呢？在以下几种情况下，确实需要克隆那些已经实例化的对象：

依赖于外部资源或硬件密集型操作进行新对象的创建的情况。
获取相同对象在相同状态的拷贝而无需进行重复获取状态操作操作的情况。
在不确定所需具体类时需要对象的实例的情况。

先来看一个原型模式的类图，如图1-1

6a3715e010974631b67ee4ea1c1acd39.png


图1-1


从上面类图中，我们可以看到在原型模式中，主要涉及以下两个类： 

Prototype （抽象原型类）：声明了 clone()方法的接口或基类，其中 clone() 方法必须由派生对象实现。在简单场景中，不需要这种基类，只需要直接具体类就足够了。
ConcretePrototype（具体原型类）：用于实现或扩展 clone() 方法的类。clone() 方法必须要实现，因为它返回了类型的新实例。如果只在基类中实现了 clone() 方法，却没有在具体原型类中实现，那么当我们在具体原型类的对象上调用该方法时，会返回一个基类的抽象原型对象。

我们知道如果在接口中声明 clone() 方法，那么在编译阶段就会强制必须在类的实现里面实现 clone() 方法。如果是多继承结构中，父类实现了 clone() 方法，继承自它的子类将不会强制执行 clone() 方法。

2、浅拷贝与深拷贝

原型模式中既然提到了对象的拷贝，那么就得注意拷贝的深度。

2.1、概念

浅拷贝：当拷贝的对象只包含简单数据类型（如：int 和 float）或不可变的对象（字符串）时，就直接将这些字段复制到新对象中。浅拷贝是一种仅将本对象作为拷贝内容的方法。
深拷贝：当拷贝的对象包含对其他对象的引用时，如果引用对象不能共用时，就需要用到深拷贝，不仅要拷贝当前属性，还要拷贝当前属性的引用对象。

注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

如何实现？

在 Java 中需要拷贝的原型类，需要实现 cloneable 接口，重写 clone() 方法，才可以实现类的拷贝。

2.2、Java 中的深浅拷贝

浅拷贝：

当类的成员变量是基本数据类型时，浅拷贝会将原对象的属性值赋值给新对象。
当类中成员变量时引用数据类型时，浅拷贝 会将 原对象的引用数据类型的地址 赋值给新对象的成员变量。也就是说 两个对象共享了同一个数据。当其中一个对象修改成员变量的值时，另外一个的值也会随之改变。

深拷贝：

无论是基本数据类型还是引用数据类型，都会去开辟额外的空间给新对象。不会出现浅拷贝中存在的问题。
当一个类中只有 基本数据类型时，浅拷贝与深拷贝是同样的。
当一个类中含有 引用数据类型是，浅拷贝只是拷贝一份引用，修改浅拷贝的值，原来的也会跟着变化。

实例

有一个叫张三的人，他想克隆自己，减轻自己的工作任务。

要实现克隆，需要实现Cloneable标志接口，并实现里面的clone方法。
浅拷贝

Person类 

类中为基本数据类型
注意，String 不是基本数据类型，但是因为String 是final 修饰的。改变这个值 其实是new 一个新String对象,所以不会影响之前的原对象。
    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class Person implements Cloneable {
     
        private String name;
        
        private int age;
     
        
        public Person(String name, int age) {
            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 super.toString()+">>{name="+this.name+",age="+this.age+"}";
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {//重写clone方法
            Person person = null;
            person = (Person) super.clone();
            return person;
        }
    }
Client类 
    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class Client {
     
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person("飞哥",28);
            Person clonePerson = (Person) person.clone();
            System.out.println("源对象");
            System.out.println(person);
            System.out.println("浅拷贝对象");
            System.out.println(clonePerson);
            System.out.println("修改拷贝对象的值");
            clonePerson.setName("跟着飞哥学编程");
            clonePerson.setAge(18);
            System.out.println("修改拷贝对象后，源对象："+person);
            System.out.println("修改拷贝对象后，拷贝对象："+clonePerson);
        }
        
    }

从上面的示例代码可以看到修改拷贝对象的值，不影响源对象的值。

81c84a21ee0248c988ff2918e8ac2689.png

当类中含有引用数据类型的对象（女朋友）时

GirlFriend类
    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class GirlFriend implements Cloneable {
     
        private String name;
        
        private float height;
     
        
        public GirlFriend(String name, float height) {
            this.name = name;
            this.height = height;
        }
     
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public float getHeight() {
            return height;
        }
     
        public void setHeight(float height) {
            this.height = height;
        }
        
        @Override
        public String toString() {
            return super.toString()+">>{name="+this.name+",height="+this.height+"}";
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {//重写clone方法
            GirlFriend girlFriend = null;
            girlFriend = (GirlFriend) super.clone();
            return girlFriend;
        }
    }

修改 Person 类，增加 GirlFriend 引用对象，并修改 toString() 方法。

    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class Person implements Cloneable {
     
        private String name;
        
        private int age;
        
        private GirlFriend girlFriend;
     
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public Person(String name, int age,GirlFriend girlFriend) {
            this.name = name;
            this.age = age;
            this.girlFriend = girlFriend;
        }
     
        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 GirlFriend getGirlFriend() {
            return girlFriend;
        }
     
        public void setGirlFriend(GirlFriend girlFriend) {
            this.girlFriend = girlFriend;
        }
     
        @Override
        public String toString() {
            return super.toString()+">>{name="+this.name+",age="+this.age+",girlFriend={name="+girlFriend.getName()+",height="+girlFriend.getHeight()+"}}";
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {//重写clone方法
            Person person = null;
            person = (Person) super.clone();
            return person;
        }
    }
Client2 再次使用Clone方法。
    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class Client2 {
     
        public static void main(String[] args) throws CloneNotSupportedException {
            GirlFriend girlFriend = new GirlFriend("周冬雨",160.50f);
            Person person = new Person("飞哥",28,girlFriend);
            Person clonePerson = (Person) person.clone();
            System.out.println("源对象");
            System.out.println(person);
            System.out.println("浅拷贝对象");
            System.out.println(clonePerson);
            System.out.println("修改拷贝对象飞哥女朋友的值");
            clonePerson.getGirlFriend().setName("关晓彤");
            clonePerson.getGirlFriend().setHeight(174);
            System.out.println("修改拷贝对象后，源对象："+person);
            System.out.println("修改拷贝对象后，拷贝对象："+clonePerson);
        }
        
    }

查看这次代码运行结果，发现引用对象修改后，源对象的引用对象值也发生了变化。

e68e98133609416a891c32980a0b8f57.png

GirlFriend 引用类型 被克隆时，只是将原有的地址 指向了被克隆的对象。

此时 GirlFriend 还只是一个对象。只是有两个引用指向同一份地址，一个地址中存放着一个值。

其中一个引用改变 了地址中的内容，另外一个也会跟着改变。
深拷贝的两种实现方式
方式一

使用 两层浅拷贝实现。

此时 我们使用深拷贝。 将 GirlFriend 对象也复制一份。

我们修改 Person 中的 clone() 方法

    @Override
        protected Object clone() throws CloneNotSupportedException {//重写clone方法
            Person person = null;
            person = (Person) super.clone();
            person.girlFriend = (GirlFriend) person.getGirlFriend().clone();
            return person;
        }

此时，再次运行 Client2 ，可以看到代码运行结果如下：

ba18333007124763a74130c733b1d6b1.png

发现修改拷贝对象的值，源对象的值还是原来的值，不受拷贝对象修改的影响。

此时，进行的复制 是将整个引用类型的对象，开辟了另外的空间。

复制的对象 与原有的对象 不再共享同一个 GirlFriend.

其实这种方式 也是属于浅层次的拷贝，因为 GirlFriend 类中数据类型是基本数据类型。

如果 GirlFriend 类中 还有 一层引用数据类型的话，那还需要在 clone() 方法中再添加一层，才可以实现真正的深拷贝。

所以不太推荐使用这种方式。
方式二

使用 序列化对象 实现 深拷贝

Person,GirlFriend 需要实现 Serializable 接口

具体代码如下:

    Person 类改造如下：

    package com.zhaoyanfei.designpattern.prototypepattern;
     
    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 Person implements Cloneable ,Serializable {
     
        /**
         * 
         */
        private static final long serialVersionUID = 8606208479723984421L;
     
        private String name;
        
        private int age;
        
        private GirlFriend girlFriend;
     
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public Person(String name, int age,GirlFriend girlFriend) {
            this.name = name;
            this.age = age;
            this.girlFriend = girlFriend;
        }
     
        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 GirlFriend getGirlFriend() {
            return girlFriend;
        }
     
        public void setGirlFriend(GirlFriend girlFriend) {
            this.girlFriend = girlFriend;
        }
     
        @Override
        public String toString() {
            return super.toString()+">>{name="+this.name+",age="+this.age+",girlFriend={name="+girlFriend.getName()+",height="+girlFriend.getHeight()+"}}";
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {//重写clone方法
            Person person = null;
            person = (Person) super.clone();
    //        person.girlFriend = (GirlFriend) person.getGirlFriend().clone();
            return person;
        }
        //序列化实现深拷贝
        public Person deepClone(){
            //声明流对象
            ByteArrayOutputStream bos = null;
            ByteArrayInputStream bis = null;
            ObjectOutputStream oos = null;
            ObjectInputStream ois = null;
            try {
                //创建序列化流
                bos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(bos);
                //将当前对象以对象流的方式输出
                oos.writeObject(this);
                //创建反序化流
                bis = new ByteArrayInputStream(bos.toByteArray());
                ois = new ObjectInputStream(bis);
                //将流对象反序列化，实现类的深拷贝。
                return (Person) ois.readObject();
     
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }finally {
                try {
                    //关闭资源
                    bos.close();
                    bis.close();
                    oos.close();
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
GirlFriend 类只需要再实现序列化 Serializable 即可

74bcc6306d0e469d9bd6808d0b1649b4.png

 测试类 Client3 代码如下：
    package com.zhaoyanfei.designpattern.prototypepattern;
     
    public class Client3 {
     
        public static void main(String[] args) throws CloneNotSupportedException {
            GirlFriend girlFriend = new GirlFriend("周冬雨",160.50f);
            Person person = new Person("飞哥",28,girlFriend);
            Person clonePerson = (Person) person.deepClone();
            System.out.println("源对象");
            System.out.println(person);
            System.out.println("深拷贝对象");
            System.out.println(clonePerson);
            System.out.println("修改拷贝对象飞哥女朋友的值");
            clonePerson.getGirlFriend().setName("关晓彤");
            clonePerson.getGirlFriend().setHeight(174);
            System.out.println("修改拷贝对象后，源对象："+person);
            System.out.println("修改拷贝对象后，拷贝对象："+clonePerson);
        }
        
    }

运行测试结果如下：

41703781a0f748efa9c0b41a2f8382ec.png

这种方式同样也实现了深拷贝。

注：推荐使用第二种方式实现深拷贝。

在实践中，我们应根据具体情况来决定使用深拷贝、浅拷贝或混合拷贝。通常，浅拷贝对应于聚合关系，而深拷贝对应于组合关系。

3、原型模式的优缺点

优点：

性能提高。
逃避构造函数的约束。

缺点：

配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
必须实现 Cloneable 接口

4、结语

下节分享创建型模式中的对象池模式，想要系统学习设计模式的小伙伴可以给我点个免费的关注，小编会持续完善设计模式的讲解。

文章标签：
Java
数据库
缓存
设计模式
关键词：
设计模式原型模式
设计模式创建型模式
设计模式创建型模式原型模式
跟着飞哥学编程
目录
相关文章
程序员小海绵
|
2月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑】设计模式——原型模式
对比原型模式和传统方式的实现思路、代码方案、优缺点，阐述原型模式的使用场景，以及深拷贝、浅拷贝等相关概念，并扩展原型模式在Spring源码中的应用。
程序员小海绵
42 3
【Java笔记+踩坑】设计模式——原型模式
艾利克斯冰
|
2月前
|
设计模式 Java
Java设计模式-原型模式（3）
Java设计模式-原型模式（3）
艾利克斯冰
37 0
Java设计模式-原型模式（3）
热爱技术的小郑
|
3月前
|
设计模式 存储 负载均衡
【五】设计模式~~~创建型模式~~~单例模式（Java）
文章详细介绍了单例模式（Singleton Pattern），这是一种确保一个类只有一个实例，并提供全局访问点的设计模式。文中通过Windows任务管理器的例子阐述了单例模式的动机，解释了如何通过私有构造函数、静态私有成员变量和公有静态方法实现单例模式。接着，通过负载均衡器的案例展示了单例模式的应用，并讨论了单例模式的优点、缺点以及适用场景。最后，文章还探讨了饿汉式和懒汉式单例的实现方式及其比较。
热爱技术的小郑
41 1
【五】设计模式~~~创建型模式~~~单例模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【三】设计模式~~~创建型模式~~~抽象工厂模式（Java）
文章详细介绍了抽象工厂模式，这是一种创建型设计模式，用于提供一个接口以创建一系列相关或相互依赖的对象，而不指定它们具体的类。通过代码示例和结构图，文章展示了抽象工厂模式的动机、定义、结构、优点、缺点以及适用场景，并探讨了如何通过配置文件和反射机制实现工厂的动态创建。
热爱技术的小郑
36 0
【三】设计模式~~~创建型模式~~~抽象工厂模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【二】设计模式~~~创建型模式~~~工厂方法模式（Java）
文章详细介绍了工厂方法模式（Factory Method Pattern），这是一种创建型设计模式，用于将对象的创建过程委托给多个工厂子类中的某一个，以实现对象创建的封装和扩展性。文章通过日志记录器的实例，展示了工厂方法模式的结构、角色、时序图、代码实现、优点、缺点以及适用环境，并探讨了如何通过配置文件和Java反射机制实现工厂的动态创建。
热爱技术的小郑
57 0
【二】设计模式~~~创建型模式~~~工厂方法模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 XML Java
【一】设计模式~~~创建型模式~~~简单工厂模式（Java）
文章详细介绍了简单工厂模式（Simple Factory Pattern），这是一种创建型设计模式，用于根据输入参数的不同返回不同类的实例，而客户端不需要知道具体类名。文章通过图表类的实例，展示了简单工厂模式的结构、时序图、代码实现、优缺点以及适用环境，并提供了Java代码示例和扩展应用，如通过配置文件读取参数来实现对象的创建。
热爱技术的小郑
42 0
【一】设计模式~~~创建型模式~~~简单工厂模式（Java）
花酒锄作田
|
3月前
|
设计模式 存储 XML
[设计模式]创建型模式-抽象工厂模式
[设计模式]创建型模式-抽象工厂模式
花酒锄作田
33 1
花酒锄作田
|
3月前
|
设计模式 测试技术 Go
[设计模式]创建型模式-简单工厂模式
[设计模式]创建型模式-简单工厂模式
花酒锄作田
38 1
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【四】设计模式~~~创建型模式~~~建造者模式（Java）
文章详细介绍了建造者模式（Builder Pattern），这是一种创建型设计模式，用于将复杂对象的构建与其表示分离，允许分步骤创建一个复杂的对象而无需指定其内部的具体构造细节。通过定义抽象建造者、具体建造者、指挥者和产品角色，建造者模式允许通过相同的构建过程创建不同的产品表示，提高了系统的灵活性和扩展性。
热爱技术的小郑
39 0
三分钟热度的鱼
|
4月前
|
设计模式
iLogtail设计模式问题之iLogtail中的原型模式是什么
iLogtail设计模式问题之iLogtail中的原型模式是什么
三分钟热度的鱼
36 0
iLogtail设计模式问题之iLogtail中的原型模式是什么

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern)
  • 3
    设计模式（九）：Composite组合模式 -- 结构型模式
  • 4
    Android Ap 开发 设计模式第五篇：单件模式
  • 5
    设计模式--组合模式
  • 6
    设计模式之美：Command（命令）
  • 7
    设计模式[11]-Visitor
  • 8
    深入浅出单实例Singleton设计模式
  • 9
    极速理解设计模式系列：4.原型模式(Prototype Pattern)
  • 10
    云计算设计模式（十九）——运行重构模式
  • 1
    C++一分钟之-设计模式：工厂模式与抽象工厂
    42
  • 2
    《手把手教你》系列基础篇（九十四）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇（详解教程）
    46
  • 3
    C++一分钟之-C++中的设计模式：单例模式
    53
  • 4
    《手把手教你》系列基础篇（九十三）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-上篇（详解教程）
    37
  • 5
    《手把手教你》系列基础篇（九十二）-java+ selenium自动化测试-框架设计基础-POM设计模式简介（详解教程）
    61
  • 6
    Java面试题：结合设计模式与并发工具包实现高效缓存；多线程与内存管理优化实践；并发框架与设计模式在复杂系统中的应用
    56
  • 7
    Java面试题：设计模式在并发编程中的创新应用，Java内存管理与多线程工具类的综合应用，Java并发工具包与并发框架的创新应用
    40
  • 8
    Java面试题：如何使用设计模式优化多线程环境下的资源管理？Java内存模型与并发工具类的协同工作，描述ForkJoinPool的工作机制，并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
    49
  • 9
    Java面试题：请列举三种常用的设计模式，并分别给出在Java中的应用场景？请分析Java内存管理中的主要问题，并提出相应的优化策略？请简述Java多线程编程中的常见问题，并给出解决方案
    105
  • 10
    Java面试题：设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题，Java内存模型定义了线程如何与内存交互，包括原子性、可见性、有序性，并发框架提供了更高层次的并发任务处理能力
    75

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云OSS设置跨域访问