原型模式超详解！

最新推荐文章于 2022-11-28 10:40:06 发布
最新推荐文章于 2022-11-28 10:40:06 发布
阅读量117 收藏
点赞数
分类专栏： 设计模式 文章标签： 原型模式 浅拷贝 深拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daniu_weilai/article/details/120694181
版权

文章目录

深拷贝与浅拷贝

当系统中需要大量创建相同或者相似的对象时，就可以通过“原型设计模式”来实现。原型模式是属于创建型模式。
核心思想：通过拷贝指定的"原型实例"来创建跟对象一样的新对象，一句话就是：克隆指定对象。

浅拷贝与深拷贝：

浅拷贝：拷贝一个对象时，只复制对象内部的基本数据类型，对象内部指向引用类型或者数组不复制。（其实也复制了，但是复制的是一个指针，新拷贝的对象和原型对象指向的是同一个实例）
深拷贝：拷贝一个对象时，对象内部的无论基本类型还是引用类型还是数组都复制。

//TODO 浅拷贝和深拷贝的原理图
浅拷贝

这里是引用
深拷贝
这里是引用

1.通过Cloneable

把要克隆的类实现Cloneable接口，并且实现Cloneable中的clone方法。

浅拷贝

Dog类

package com.jc.prototype;

import java.io.Serializable;

/**
* @program: 设计模式
*
* @description: 
*
* @author: Mr.Wang
*
* @create: 2021-06-13 19:34
**/
public class Dog {
    private int age;

    public Dog(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }


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

Sheep类

package com.jc.prototype;

/**
 * @program: 设计模式
 * @description:
 * @author: Mr.Wang
 * @create: 2021-06-13 18:12
 **/
public class Sheep implements Cloneable {
   private int age;
   private char sex;
   private Dog friend;

    public int getAge() {
        return age;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Dog getFriend() {
        return friend;
    }

    public void setFriend(Dog friend) {
        this.friend = friend;
    }

    public Sheep(int age, char sex, Dog friend) {
        this.age = age;
        this.sex = sex;
        this.friend = friend;
    }
    public Sheep(){

    }

    @Override
    protected Sheep clone()  {

        Sheep clone = null;
        try {
            //这里完成基本类型克隆
            clone = (Sheep) super.clone();

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return clone;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "age=" + age +
                ", sex=" + sex +
                ", friend=" + friend +
                '}';
    }
}

Client类

package com.jc.prototype;

import java.util.function.DoubleFunction;

/**
 * @program: 设计模式
 * @description:
 * @author: Mr.Wang
 * @create: 2021-06-13 18:21
 **/
public class Client {

    public static void main(String[] args) {
        Dog friend = new Dog(3);

        Sheep sheep = new Sheep(22,'男',friend);

        Sheep clone = sheep.clone();

        System.out.println("sheep' hashcode:"+sheep.hashCode()+", "+sheep+", friend' hashcode:"+sheep.getFriend().hashCode());
        System.out.println("clone' hashcode:"+clone.hashCode()+", "+clone+", friend' hashcode:"+clone.getFriend().hashCode());

        /**
         * 打印结果
         *sheep' hashcode:460141958, Sheep{age=22, sex=男, friend=Dog{age=3}}, friend' hashcode:1163157884
         *clone' hashcode:1956725890, Sheep{age=22, sex=男, friend=Dog{age=3}}, friend' hashcode:1163157884
         */
    }
}

通过打印结果可以验证这是浅拷贝，浅拷贝的不好就是，如果对引用类型数据进行修改的话，clone后的数据会跟着修改（看前边的原理图）。
例如我们的这个代码，克隆后重新设置下年龄。

 Dog friend = new Dog(3);

        Sheep sheep = new Sheep(22,'男',friend);
        Sheep clone = sheep.clone();
        //拷贝完了 如果我们在对Dog进行修改的话  clone后的对象还是会跟着更改，因为他们指向的都是friend实例
        friend.setAge(5);

打印结果为

sheep’ hashcode:460141958, Sheep{age=22, sex=男, friend=Dog{age=5}}, friend’ hashcode:1163157884
clone’ hashcode:1956725890, Sheep{age=22, sex=男, friend=Dog{age=5}}, friend’ hashcode:1163157884

那么我们如何通过Cloneable深拷贝呢？
解决办法：让引用类型也实现clone接口，在Sheep的clone方法中分两步：
①对基本类型拷贝②对引用类型的真正复制.(新new一个）

深拷贝

1.让Dog类也实现Clone接口

package com.jc.prototype;

import java.io.Serializable;

/**
* @program: 设计模式
*
* @description: 
*
* @author: Mr.Wang
*
* @create: 2021-06-13 19:34
**/
public class Dog  implements Cloneable {
    private int age;

    public Dog(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }


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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2.Sheep中的clone方法改为这样

 @Override
    protected Sheep clone()  {

        Sheep clone = null;
        try {
            //1.这里完成基本类型克隆
            clone = (Sheep) super.clone();

            //2.完成引用类型的真正克隆
            clone.friend = (Dog) friend.clone();
            
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return clone;
    }

Client类

package com.jc.prototype;

import java.util.function.DoubleFunction;

/**
 * @program: 设计模式
 * @description:
 * @author: Mr.Wang
 * @create: 2021-06-13 18:21
 **/
public class Client {

    public static void main(String[] args) {
        Dog friend = new Dog(3);

        Sheep sheep = new Sheep(22,'男',friend);
        Sheep clone = sheep.clone();
        //拷贝完了 如果我们在对Dog进行修改的话  clone后的对象还是会跟着更改，因为他们指向的都是friend实例
        friend.setAge(5);

        System.out.println("sheep' hashcode:"+sheep.hashCode()+", "+sheep+", friend' hashcode:"+sheep.getFriend().hashCode());
        System.out.println("clone' hashcode:"+clone.hashCode()+", "+clone+", friend' hashcode:"+clone.getFriend().hashCode());

        /**
         * 打印结果
         *sheep' hashcode:460141958, Sheep{age=22, sex=男, friend=Dog{age=3}}, friend' hashcode:1163157884
         *clone' hashcode:1956725890, Sheep{age=22, sex=男, friend=Dog{age=3}}, friend' hashcode:356573597
         */
    }
}

通过打印结果可以看到Sheep实例和clone实例hashcode不同，friend的hashcode也不同，就算克隆后对friend进行修改，也不会影响clone的实例，这才是真正意义上的克隆，也就是深拷贝。

2.通过对象序列化实现深拷贝

Dog类

package com.jc.prototype;

import java.io.*;

/**
* @program: 设计模式
*
* @description: 
*
* @author: Mr.Wang
*
* @create: 2021-06-13 19:34
**/
public class Dog  implements Serializable{
    private int age;

    public Dog(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

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

Sheep类

package com.jc.prototype;

import java.io.*;

/**
 * @program: 设计模式
 * @description:
 * @author: Mr.Wang
 * @create: 2021-06-13 18:12
 **/
public class Sheep implements Serializable {
   private int age;
   private char sex;
   private Dog friend;

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Dog getFriend() {
        return friend;
    }

    public void setFriend(Dog friend) {
        this.friend = friend;
    }

    public Sheep(int age, char sex, Dog friend) {
        this.age = age;
        this.sex = sex;
        this.friend = friend;
    }
    public Sheep(){

    }


    public Sheep 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);//反序列化

            Sheep clone = (Sheep) ois.readObject();

            bos.flush();
            oos.flush();

            return clone;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    @Override
    public String toString() {
        return "Sheep{" +
                "age=" + age +
                ", sex=" + sex +
                ", friend=" + friend +
                '}';
    }
}

Client类

package com.jc.prototype;

import java.util.function.DoubleFunction;

/**
 * @program: 设计模式
 * @description:
 * @author: Mr.Wang
 * @create: 2021-06-13 18:21
 **/
public class Client {

    public static void main(String[] args) {
        Dog friend = new Dog(3);

        Sheep sheep = new Sheep(22,'男',friend);
        Sheep clone = sheep.deepclone();
        //拷贝完了 如果我们在对Dog进行修改的话  clone后的对象还是会跟着更改，因为他们指向的都是friend实例
        friend.setAge(5);

        System.out.println("sheep' hashcode:"+sheep.hashCode()+", "+sheep+", friend' hashcode:"+sheep.getFriend().hashCode());
        System.out.println("clone' hashcode:"+clone.hashCode()+", "+clone+", friend' hashcode:"+clone.getFriend().hashCode());

        /**
         * 打印结果
         *sheep' hashcode:2133927002, Sheep{age=22, sex=男, friend=Dog{age=5}}, friend' hashcode:1836019240
         *clone' hashcode:381259350, Sheep{age=22, sex=男, friend=Dog{age=3}}, friend' hashcode:2129789493
         */
    }
}

通过打印结果可以看出来完成了深拷贝。

3.在spring源码中引用

test方法

 @Test
    public void test2(){

        AnnotationConfigApplicationContext ApplicationContext =
                new AnnotationConfigApplicationContext(txconfig.class);
        System.out.println("容器初始化完成");

        Dog dog =(Dog) ApplicationContext.getBean("dog");
        System.out.println("dog' hashcode:"+dog.hashCode());
        Dog dog1 =(Dog) ApplicationContext.getBean("dog");
        System.out.println("dog1' hashcode:"+dog1.hashCode());
        ApplicationContext.close();

        /**Scope=prototype
         *
         * @Bean
         * @Scope("prototype")
         * public Dog dog(){
         *    return new Dog();
         *  }
         * 打印结果
         * dog' hashcode:2134607032
         * dog1' hashcode:2134607032
         */

        /**Scope=singleton
         *
         * @Bean
         * @Scope("singleton")
         * public Dog dog(){
         *    return new Dog();
         *  }
         * 打印结果
         *dog' hashcode:2134607032
         *dog1' hashcode:1470344997
         */
    }

通过hashcode可以看出来，当Scope=prototype，即原型模式创建对象；当Scope=singleton时，即单例模式创建对象。

debug追踪一下，发现在AbstractFactory中的doGetBean方法中有一段这样代码

				if (mbd.isSingleton()) {//如果是单例模式的话,创建单例。
	                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {//如果是原型模式的话，创建一个原型实例。
                    var12 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

通过if (mbd.isSingleton())和else if (mbd.isPrototype())来判断是通过单例模式创建对象还是原型模式创建对象。

总结

好

1.相比于之前我们复制对象，原型设计模式效率更高。
2.如果原型对象发生变化，克隆的对象也会发生变化，无需修改代码。（浅克隆）

不好

1.实现深克隆的时候可能需要比较复杂的代码
2需要为每一个类配置一个克隆方法，对后期拓展的类不难，，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则。

王哈哈哈.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式-原型模式详解
11-24
Java 设计模式 - 原型模式详解 原型模式是 Java 设计模式之一，它用于创建对象时，指定创建对象的类型，并通过拷贝这些原型创建新的对象。该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原...
Python设计模式之原型模式实例详解
09-19
主要介绍了Python设计模式之原型模式,结合实例形式较为详细的分析了Python原型模式的概念、原理、用法及相关操作注意事项,需要的朋友可以参考下
原型模式详解
weixin_48478425的博客
12-25 570
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。拷贝是原型模式的精髓所在。
原型模式详解 (附java语言源码)
热门推荐
数据知道的博客
06-04 1万+
原型模式（Prototype Pattern）: 用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。(Specify the kinds of objects to create using a prototypical instance, and create new objects by copying the prototype.) 通过原型模式，绕过构造方法创建对象，利...
javascript原型模式用法实例详解
10-24
主要介绍了javascript原型模式用法,以实例形式较为详细的分析了javascript原型模式的原理与使用技巧,需要的朋友可以参考下
详解JAVA 原型模式
08-19
主要介绍了JAVA 原型模式的的相关资料，文中讲解非常细致，实例帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Android编程设计模式之原型模式实例详解
01-20
本文实例讲述了Android编程设计模式之原型模式。分享给大家供大家参考，具体如下： 一、介绍 原型模式是一个创建型的模式。原型二字表明了该模型应该有一个样板实例，用户从这个样板对象中复制出一个内部属性一致的...
设计模式-原型模式详解
rizon886的博客
06-27 112
一、原型模式的概念 　　原型模式属于创建型设计模式。当要创建的对象类型由原型实例确定时使用它，该实例被克隆以生成新对象。 　　此模式用于 　　1、避免客户端应用程序中的对象创建者的子类，如工厂方法模式。 　　2、避免以标准方式创建新对象的固有成本（例如，使用'new'关键字），当它对于给定的应用程序来说过于昂贵时。 　　上述定义来自wiki，简单来说，就是创建一个全新的对象代价太高时，比如耗时太长时，能直接从现有实例中以较小的代价克隆出一个对象。 二、原型模式的实现 　　实现原型模式的方式之一为克...
详解设计模式：原型模式
栗筝i的博客
11-28 2112
原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。 原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。 本篇内容包括：关于原型模式、原型模式-浅拷贝实现、原型模式-深拷贝实现
设计模式之原型模式详解（附应用举例实现）
pursuit的博客
04-22 7992
设计模式之原型模式详解（附应用举例实现）
原型模式
Erick Lv的笔记
06-11 267
模式简介 当一个对象需要完全拷贝另一个对象的状态时，需要使用这个模式。此时，拷贝的新对象和原来的对象拥有同样的行为状态。这么做的优势是，新建对象的时候，我们不需要人工把新对象改变到原来对象的状态，而是复制函数帮我们处理完毕了。 这个模式一般用在那些需要克隆有特定状态的对象。比如一个对象当前存储了某些特定的数值，这些值非常多而且复杂，那么此时就可以使用这个模式了。C++中通过拷贝构造函数来实现。 模...
设计模式之原型模式
helinlin007的专栏
03-18 2841
原型模式也是属于创建者模式中的一种，他与之前的几种模式想比较而言，可能更加方便理解。记得小时候吃的那些有颜色的米糕，每一个米糕上卖弄都有花纹，虽然每一个米糕都不尽相同，但是上面的花纹都是来自同一个板模上来的。        上面的比喻不太合理，换一个比喻吧，假如你到商场去买衣服，上面挂着很多的样品，然后你会试穿样品，等到感觉合身的时候。你肯定会叫售货员换一套不是样品的衣服给你的，同时你也可以换其
JAVA设计模式2：原型模式
ccystewart的博客
05-09 239
JAVA设计模式1：原型模式 原型模式的定义与特点 原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。 原型模式的...
23种设计模式全解析
arthur.dy.lee的专栏
02-17 5080
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
23种设计模式（5）：原型模式
java开发指南博客 【转载】
03-26 1203
定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 类型：创建类模式 类图： 原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件： 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在jav...
原型模式python
最新发布
04-11
原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需显式地使用构造函数。在Python中，可以使用原型模式通过复制对象来创建新对象。 在Python中，可以使用`copy`模块来实现原型模式。`copy`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值