二十三种设计模式-原型模式

最新推荐文章于 2024-09-28 22:54:00 发布
最新推荐文章于 2024-09-28 22:54:00 发布
阅读量86 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013982921/article/details/114679204
版权

1、原型模式定义

      不通过 new 关键字来产生一个对象，而是通过对象复制来实现的模式就叫做原型模式。原型模式的核心是一个clone方法，通过该方法进行对象的拷贝，Java中提供了一个Cloneable接口来标示该对象是可拷贝的。原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节

下面就以一个克隆羊的问题来说明原型模式

2、克隆羊问题

假如现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊 属性完全相同的 10只羊

2.1、传统方法思路

1）思路分析

2）代码实现

public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //传统的方法
        Sheep sheep = new Sheep("tom", 1, "白色");

        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        //....

        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
        //...
    }
}

3）传统方法优缺点

  1. 优点是比较好理解，简单易操作。
  2. 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
  3. 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
  4. 改进的思路分析

思路：Java 中 Object 类是所有类的根类，Object 类提供了一个 clone()方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的 Java 类必须要实现一个接口 Cloneable，该接口表示该类能够复制且具有复制的能力  =>原型模式

3、原型模式原理结构图-uml 类图

  • 原理结构图说明
  1. Prototype : 原型类，声明一个克隆自己的接口
  2. ConcretePrototype: 具体的原型类,  实现一个克隆自己的操作
  3. Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样）

4、原型模式代码实现

public class Sheep implements Cloneable {

    private String name;
    private int age;
    private String color;

    public Sheep friend; //是对象,  克隆是会如何处理,  默认是浅拷贝

    public Sheep(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }

    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 String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Sheep{" + "name='" + name + '\'' + ", age=" + age + ", color='" + color + '\'' + '}';
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return sheep;
    }
}
public class Client {

    public static void main(String[] args) {
        System.out.println("原型模式完成对象的创建");
       // TODO Auto-generated method stub
        Sheep sheep = new Sheep("tom", 1, "白色");

        sheep.friend = new Sheep("jack", 2, "黑色");

        Sheep sheep2 = (Sheep) sheep.clone(); //克隆
        Sheep sheep3 = (Sheep) sheep.clone(); //克隆
        Sheep sheep4 = (Sheep) sheep.clone(); //克隆
        Sheep sheep5 = (Sheep) sheep.clone(); //克隆


        System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.friend.hashCode());
        System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
        System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
        System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
    }
}

5、原型模式在spring框架中使用

  1. Spring 中原型 bean 的创建，就是原型模式的应用，即在Spring中配置bean的时候，scope属性可以配置一个prototype值，该值指定该bean的创建是使用原型模式
  2. 在创建ioc容器后，通过getBean()获取bean对象时，往里追可以发现在核心方法处spring对bean的scope属性进行了判断，配置了prototype时，进入了原型模式的使用

spring源码如下

public Object getBean(String name) throws BeansException {
    this.assertBeanFactoryActive();
    //我们先进入getBeanFactory()方法，看看得到的是哪个BeanFactory，再寻找他的getBean()方法
    return this.getBeanFactory().getBean(name);
}
 
//追踪发现这是一个抽象方法，应该是由AbstractApplicationContext的子类实现
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
private DefaultListableBeanFactory beanFactory;
//实现了getBeanFactory方法，确保了线程安全的前提下返回了一个DefaultListableBeanFactory
public final ConfigurableListableBeanFactory getBeanFactory() {
    synchronized(this.beanFactoryMonitor) {
        if (this.beanFactory == null) {
            throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext");
        } else {
            return this.beanFactory;
        }
    }
}
public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);
   			.................
 
            if (mbd.isSingleton()) {
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                        return this.createBean(beanName, mbd, args);
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            //判断了是否设置了原型模式
            } else if (mbd.isPrototype()) {
                var11 = null;
 
                Object prototypeInstance;
                try {
                    this.beforePrototypeCreation(beanName);
            	    //进入了原型模式的对象创建
                    prototypeInstance = this.createBean(beanName, mbd, args);
                } finally {
                    this.afterPrototypeCreation(beanName);
                }
 
                bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                ...................

6、深入讨论-浅拷贝和深拷贝

    6.1、浅拷贝的介绍

  1. 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
  2. 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
  3. 前面我们克隆羊就是浅拷贝
  4. 浅拷贝是使用默认的 clone()方法来实现

     sheep = (Sheep) super.clone();

   6.2、深拷贝基本介绍

  1. 复制对象的所有基本数据类型的成员变量值
  2. 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝
  3. 深拷贝实现方式 1：重写 clone 方法来实现深拷贝
  4. 深拷贝实现方式 2：通过对象序列化实现深拷贝(推荐)

   6.3、深拷贝代码实现

public class DeepCloneableTarget implements Serializable, Cloneable {

    private String cloneName;

    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class DeepProtoType implements Serializable, Cloneable {
    public String name;

    public DeepCloneableTarget deepCloneableTarget;

    public DeepProtoType() {
        super();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {


        Object deep = null;
        //这里完成对基本数据类型(属性)和 String 的克隆
        deep = super.clone();
        //对引用类型的属性，进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();

        // TODO Auto-generated method stub
        return deepProtoType;
    }

    //深拷贝 - 方式 2 通过对象的序列化实现 (推荐)
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;


        try {

            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); //当前这个对象以对象流的方式输出

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtoType copyObj = (DeepProtoType) ois.readObject();


            return copyObj;
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                // TODO: handle exception
                System.out.println(e2.getMessage());
            }
        }
    }

}
public class Client {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub 
        DeepProtoType p = new DeepProtoType();
        p.name = "宋江";

        p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");

        //方式 1  完成深拷贝

        //	DeepProtoType p2 = (DeepProtoType) p.clone();
        //
        //	System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        //	System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());

        //方式 2  完成深拷贝
        DeepProtoType p2 = (DeepProtoType) p.deepClone();


        System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    }
}

7、原型模式注意事项

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
  4. 在实现深克隆的时候可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则

 

11宁静致远
关注
专栏目录
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
JAVA-设计模式-创建型模式-原型模式
08-10
JAVA-设计模式-创建型模式-原型模式
学习笔记【23种设计模式-第四节：Prototype原型模式 -克隆羊、深浅拷贝】
qq_53273362的博客
12-15 119
Prototype原型模式 简述： 原型模式（Prototype模式）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。 原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建的细节。 工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone() 形象的理解：孙悟空拔出猴毛，变出其他孙猴子。 例子：克隆羊： Sheep类实现了Cloneable接口，重写了clone方法： p
小白必备之原型模式总结(浅克隆和深克隆)
Code皮皮虾的博客
08-01 685
文章目录原型模式-基本介绍传统方式原型模式解决原型模式(浅拷贝与深拷贝)浅拷贝深拷贝总结 原型模式-基本介绍 原型模式(Prototype模式)是指：用原型实例指定创建对象地种类，并且通过拷贝这些原型，创建新的对象。 原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制地对象，无需知道创建细节。 工作原理：通过一个原型对象传给要发动创建地对象，这个要发动创建地对象通过请求原型对象拷贝他们自己来实施创建，即 对象.clone() 优点： 性能提高。 逃避构造函数的约束。 缺点： 配备克隆方法
设计模式：快速理解原型模式和应用
热门推荐
张彦峰的博客
05-12 166万+
一、原型模式的定义与理解 （一）基本定义 （二）基本理解分析 （三）在Spring中的具体体现 二、具体简单实现方式 (一)实现原型类具备的三个条件 （二）具体举例 三、深拷贝、浅拷贝与原型模式的解决方案 （一）理解复制的含义，去除原有的误解 （二）浅拷贝及其带来的问题 1.新建一个上司类作为员工类的某个属性 2.测试浅拷贝带来的问题 （三）通过深拷贝来解决问题 四、原型模式的应用场景分析
二十三种常见设计模式-简介
KevinC0211的博客
11-16 2814
设计模式分类 设计模式根据目的可分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式，原型模式。 结构性模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 设计模式的7大原则： 单一原则（SRP）：一个类（或方法）只做一件事。 开放-封闭原则（OCP）：软件实体（类、模块、函数）可以拓展，但
设计模式 - 创建型模式_原型模式
小工匠
01-27 2万+
原型模式主要解决的问题就是创建重复对象，⽽这部分 对象 内容本身⽐较复杂，⽣成过程可能从库或者RPC接⼝中获取数据的耗时较⻓，因此采⽤克隆的⽅式节省时间。
设计模式---原型模式
shenzy
12-05 2765
原型模式是一种创建型设计模式,Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。原型模式包含以下角色：原型模式的克隆分为浅克隆和深克隆Java中的Object类中提供了clone()方法来实现浅克隆。Cloneable接口是Java提供的抽象原型类而实现了Cloneable接口的子实现类就是具体原型类
Java设计模式-创建型设计模式-原型模式
Fatter$hday的博客
04-20 1348
Java设计模式-创建型设计模式-原型模式
深入理解设计模式-原型模式
少说，多做
05-19 8217
文章目录一、定义二、使用场景三、代码样例1.类图2.简历实体类3.工作经历实体类4.客户端类4.输出四、优缺点五、两种实现方式：浅拷贝与深拷贝1.浅拷贝2.深拷贝结尾 一、定义 原型模式使用原型实例指定创建对象的种类，并且通过拷贝原型对象创建新的对象。原型模式本质是一种克隆对象的方法，其核心是重写Object中的clone方法，调用该方法可以在内存中进行对象拷贝。 Java提供了一个标记接口——Cloneable，实现该接口完成标记，在JVM中具有这个标记的对象才有可能被拷贝。如果不实现该接口，克隆对象会
设计模式-原型模式
Silas 蝈蝈 博客
08-31 1万+
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式本质是一种克隆对象的方法，其核心是重写Object中的clone方法，调用该方法可以在内存中进行对象拷贝。Java提供了一个标记接口——Cloneable，实现该接口完成标记，在JVM中具有这个标记的对象才有可能被拷贝。如果不实现该接口，克隆对象会抛出CloneNotSupportedException异常。原型模式可以理解为：一个对象的产生可以不由零起步，直接从一个已经具备一定雏形的对象克隆，然后再修改为生产需要的对象。
设计模式 - 原型模式
Circ
04-14 4598
原型模式是什么 原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。 使用情景： 首先从实际生活来了解原型模式的由来，假设你有一份非常好的讲义，你的朋友也想要一份，那么怎么办？重新手抄一份？显然不是，当然是用复印机复印一份来得方
c#代码介绍23种设计模式-06原型模式(附代码)
09-22
然而原型模式可以很好地解决这个问题，因为每个类实例都是相同的，当我们需要多个相同的类实例时，没必要每次都使用new运算符去创建相同的类实例对象， 此时我们一般思路就是想——只创建一个类实例对象，如果后面...
24设计模式-原型模式1
08-04
原型模式是一种设计模式，主要目的是通过复制现有对象来创建新对象，从而简化创建过程并减少对象构造的开销。在Java中，实现原型模式通常涉及`Cloneable`接口和`clone()`方法。`Cloneable`接口是一个标记接口，类...
C++设计模式-原型模式
06-03
原型模式（Prototype Pattern）是软件设计模式中的一种创建型模式，它提供了一种复制已有对象而不必知道其具体类别的方法。在C++中，原型模式常常利用拷贝构造函数或赋值运算符来实现对象的克隆。这种模式在需要频繁...
设计模式、系统设计 record part02
m0_47505062的博客
09-27 1227
软件设计模式1.应对重复发生的问题2.解决方案3.可以反复使用1.本质是面向对象2.优点很多1.创建型-创建和使用分离2.结构型-组合3.行为型-协作5+7+11=23种模式UML-统一建模语言-Unified Modeling Language1.可视化图形化2.各种图（9种图）3.可以同时表示静态信息、动态信息类图就是图形化显式类关联关系。
单例设计模式
SunnyRivers
09-26 928
单例模式（Singleton Pattern）指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式。单例模式在现实生活中的应用非常广泛，例如公司CEO、部门经理等都属于单例模型。J2EE标准中的ServletContext和ServletContextConfig、Spring框架应用中的ApplicationContext、数据库中的连接池等也都是单例模式。对于Java来说，单例模式可以保证在一个JVM中只存在单一实例。单例模式的应用场景主要有以下几个方面。
Qt C++设计模式-＞享元模式
m0_46494667的博客
09-24 1407
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享相同对象来减少内存使用，尤其适合在大量重复对象的情况下。它通过将对象的可共享部分抽取出来，并在多个上下文中共享，从而避免对象的多次创建。
行为设计模式 -模板方法模式- JAVA
最新发布
智的博客
09-28 1687
模板方法是一种行为设计模式。模板方法设计模式用于创建方法存根并将某些实现步骤推迟到子类。模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构**的情况下，重新定义算法中的某些步骤。在面向对象程序设计过程中，我们常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。通俗理解，就是设计构建一个对象的时候，类的步骤已经固定了，可是某些类的实现逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值