设计模式——原型模式

优质博文:IT-BLOG-CN

原型模式(Prototype Pattern): 是用于创建重复对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。

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

一、基本介绍

● 原型模式:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象。
● 原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的细节。
● 工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对像拷贝它们自己来实现创建,及对象的clone()。

二、类图

原理结构图说明:
1)、Prototype:原型类,声明一个克隆自己的接口 clone。
2)、ConcretePrototype:具体的原型类,实现一个克隆自己的操作。
3)、Client 让一个原型对象克隆自己,从而创建一个新的对象(相当于属性)。

设计模式——原型模式_第1张图片

三、原型模式案例分析

【1】克隆类需要实现 Cloneable 重写 clone 方法。

package com.yintong.principle.singleresponsibility;
//写一个手机的克隆类
public class ConcretePrototype implements Cloneable{
	//名称
	private String name;
	//号码
	private Long number;
	//构造器
	public ConcretePrototype(String name, Long number) {
		super();
		this.name = name;
		this.number = number;
	}

	@Override
	public String toString() {
		return "ConcretePrototype [name=" + name + ", number=" + number + "]";
	}
        // 克隆用到的主要部分
	@Override
	protected Object clone() throws CloneNotSupportedException {
		ConcretePrototype ConcretePrototype = null;
		try {
			ConcretePrototype = (ConcretePrototype) super.clone();
		}catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return ConcretePrototype;
	}
}

【2】客户端调用 clone 方法,实现原型模式。

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		//创建一个对象
		ConcretePrototype prototype = new ConcretePrototype("华为", new Long(1568889932));
		//通过原型模式完成对象的创建  克隆
		ConcretePrototype p2 = (ConcretePrototype)prototype.clone();
	}
}

四、Spring 中的应用

【1】当 scope 配置为 prototype 时,表示原型模式。

 
 <bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>

【2】查看底层调用:

else if (mbd.isPrototype()) {
	// It's a prototype -> create a new instance.
	Object prototypeInstance = null;
	try {
		beforePrototypeCreation(beanName);
	        prototypeInstance = createBean(beanName, mbd, args);
	}
	finally {
		afterPrototypeCreation(beanName);
	}
        // ***  创建一个代理类  ***
	bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

五、浅拷贝

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

六、深拷贝

● 复制对象的所有基本数据类型的成员变量值。
● 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对整个对象进行拷贝。
● 深拷贝的实现方式有两种,第一种是重写 clone 方法来实现深拷贝,第二种是通过序列化实现深拷贝,也是推荐的一种。

七、深克隆的两种实现方法

【1】通过调用引用类型的克隆方法,实现深拷贝。缺点就是当引用类型多时,不建议采用。

public class DeepClone implements Cloneable{
	//基本数据类型
	private String name;
	//引用数据类型
	private Spare spare;
	
	//重写clone方法,调用引用类型的克隆方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		DeepClone deepClone = null;
		deepClone = (DeepClone)super.clone();
		
		//克隆引用数据类型
		deepClone.spare = (Spare) spare.clone();
		return deepClone;
	}
}

【2】通过序列化的方式,实现深拷贝:也是建议使用的方法。

public class DeepClone implements Serializable{
	/**
	 * 序列化 ID
	 */
	private static final long serialVersionUID = 1L;
	//数据类型  略。。。。
	//重写clone方法,调用引用类型的克隆方法
	protected Object deepClone(){
		ByteArrayOutputStream BOStream = null;
		ObjectOutputStream OOSream = null;
		ByteArrayInputStream BIStream = null;
		ObjectInputStream OIStream =null;
		try {
			//序列化
			BOStream = new ByteArrayOutputStream();
			OOSream = new ObjectOutputStream(BOStream);
			//将当前对象写入流中
			OOSream.writeObject(this);
			
			//反序列化
			BIStream = new ByteArrayInputStream(BOStream.toByteArray());
			OIStream = new ObjectInputStream(BIStream);
			DeepClone deepClone = (DeepClone) OIStream.readObject();
			return deepClone;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}finally {
			try {
				BOStream.close();
				OOSream.close();
				BIStream.close();
				OIStream.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
}

八、原型模式的注意事项和细节

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

你可能感兴趣的:(设计模式,设计模式,原型模式,java,后端,面试,职场和发展,系统架构)