设计模式-原型模式及应用

于 2021-03-11 22:40:35 发布
阅读量118 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fw19940314/article/details/114682167
版权

在一些系统中，可能会出现大量的相同的对象或者相似的对象，且创建此类对象时，会比较复杂且耗资源。那么使用本节需要讲的原型模式，可以解决此类问题。

原型模式

原型（Prototype）模式的定义如下：使用已经创建的对象，通过复制原型对象的方式创建相同或者相似的对象。无需知道创建对象的细节。

原型模式结构与实现

Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

  1. 模式的结构
    原型模式包含以下主要角色。
  • 抽象原型类：规定了具体原型对象必须实现的接口，在这里指Cloneable 接口。
  • 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
  • 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

如果clone时，不实现Cloneable接口，编译器会抛出一个 CloneNotSupportedException 异常。

原型结构图：
在这里插入图片描述

一般情况下，使用原型模式（Java clone()）需要满足以下条件：

  • 对任何对象 o，都有 o.clone() != o。换言之，克隆对象与原型对象不是同一个对象。
  • 对任何对象 o，都有 o.clone().getClass() == o.getClass()。换言之，克隆对象与原型对象的类型一样。
  • 如果对象 o 的 equals() 方法定义恰当，o.clone().equals(o) 应当成立。

代码实例：
这里通过写一个悟空类，然后通过clone方法，复制悟空对象。

  • realizetype(可复制对象)
 public class Wukong implements Cloneable{
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
	private String name;
	
	private int 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 "[name=" + name + ", age=" + age + "]";
	}
}
  • client 使用方
public class Client {

	public static void main(String[] args) throws CloneNotSupportedException {
		Wukong wukong =	new Wukong();
		wukong.setName("齐天大圣");
		wukong.setAge(500);
		
		System.out.println("wukong:"+wukong);
		
		Wukong wukong2 =  (Wukong)wukong.clone();
		System.out.println("wukong2:"+wukong2);
		
		System.out.println(wukong == wukong2);
	}
}

执行结果

wukong:[name=齐天大圣, age=500]
wukong2:[name=齐天大圣, age=500]
false

复制出来的对象内容一致，但不是同一地址指向的对象。完全是两个相同内容的对象，这就达到了我们原型复制的效果。

深拷贝&浅拷贝

下面再写一个代码示例。上面我们复制的对象属性都是简单的基础类型。

  • 原型对象1

/**
 * 深拷贝目标对象
 * @author fengwei
 *
 */
public class DeepCloneOjb implements Serializable, Cloneable {
	private static final long serialVersionUID = 1L;
	
	private String name;
	
	private Integer age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	@Override
	public String toString() {
		return ", DeepCloneOjb hashcode = [" + hashCode() + " ] , data = [name=" + name + ", age=" + age + "]";
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}
}
  • 原型对象2
public class DeepPrototype implements Cloneable, Serializable{
	
	private static final long serialVersionUID = 1L;
	
	private String userName;
	
	private DeepCloneOjb deepCloneOjb;
	
	

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public DeepCloneOjb getDeepCloneOjb() {
		return deepCloneOjb;
	}

	public void setDeepCloneOjb(DeepCloneOjb deepCloneOjb) {
		this.deepCloneOjb = deepCloneOjb;		
	}
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {		
		return super.clone();
	}

	@Override
	public String toString() {
		return "DeepPrototype hashcode = "+ hashCode() +", data =  [userName=" + userName + ", deepCloneOjb=" + deepCloneOjb + "]";
	}
}
  • client 使用方
public static void main(String[] args) throws CloneNotSupportedException {
		DeepCloneOjb deepCloneOjb = new  DeepCloneOjb();
		deepCloneOjb.setName("deepCloneOjb");
		deepCloneOjb.setAge(10);
		
		// 原型对象
		DeepPrototype deepPrototype =  new DeepPrototype();
		deepPrototype.setUserName("deepPrototype");
		deepPrototype.setDeepCloneOjb(deepCloneOjb);
		
		//clone
		DeepPrototype deepPrototype2 = (DeepPrototype) deepPrototype.clone();
		
		System.out.println("deepPrototype="+deepPrototype);
		System.out.println("deepPrototype2="+deepPrototype2);
	}

执行结果：

deepPrototype=DeepPrototype hashcode = 2018699554, data =  [userName=deepPrototype, deepCloneOjb=, DeepCloneOjb hashcode = [1311053135 ] , data = [name=deepCloneOjb, age=10]]

deepPrototype2=DeepPrototype hashcode = 118352462, data =  [userName=deepPrototype, deepCloneOjb=, DeepCloneOjb hashcode = [1311053135 ] , data = [name=deepCloneOjb, age=10]]

结果是DeepPrototype对象的地址值和 deepPrototype2的地址值是不同的，但是内部的 DeepCloneOjb 对象的地址值指向的是同一个对象。

这就是深拷贝问题，Java提供的Clone，只适用于简单基本数据类型，对于引用数据类型（类，接口，数组等复杂类型），拷贝的是对象地址。

深拷贝解决

我们可以通过嵌套拷贝的方式，一层层的拷贝来实现深拷贝。还是上例的代码，这里我对 DeepPrototype类的 clone() 方法 做如下改动：

@Override
	protected Object clone() throws CloneNotSupportedException {
		//这里完成对基本数据类型(属性)和String的克隆
		Object deep = super.clone(); 
		//对引用类型的属性，进行单独处理
		DeepPrototype deepProtoType = (DeepPrototype)deep;
		
		deepProtoType.deepCloneOjb  = (DeepCloneOjb)deepCloneOjb.clone();
		
		return deepProtoType;
        }

执行结果：

deepPrototype=DeepPrototype hashcode = 2018699554, data =  [userName=deepPrototype, deepCloneOjb=, DeepCloneOjb hashcode = [1311053135 ] , data = [name=deepCloneOjb, age=10]]
deepPrototype2=DeepPrototype hashcode = 118352462, data =  [userName=deepPrototype, deepCloneOjb=, DeepCloneOjb hashcode = [1550089733 ] , data = [name=deepCloneOjb, age=10]]

发现内部的引用类型的对象地址也不同了！

克隆对单例影响

我们知道克隆的话是对目标对象，拷贝出一个内容一致的对象。对于某个系统来说，如果目标对象恰好是一个单例对象，我们通过克隆的方式，是否会破坏单例的特性。

代码案例：

public class ReflectClone implements Cloneable {
	
	private static ReflectClone instance = new ReflectClone();
    
	private ReflectClone() {
    }
    
    public static ReflectClone getInstance() {
        return instance;
    }
    
    @Override
    public ReflectClone clone() {
        try {
            return (ReflectClone) super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
    
    public static void main(String[] args) {
    	//原型对象
    	ReflectClone protoType = ReflectClone.getInstance();
        //clone
    	ReflectClone cloneType = protoType.clone();
        System.out.println(protoType==cloneType);
	}
}

执行结果false

从结果来看，确实创建了两个不同的对象。实际上防止复制破坏单例对象的解决思路非常简单，禁止复制便可。那么我们的单例类不实现 Cloneable 接口，要么我们重写 clone() 方法，在 clone() 方法中返回单例对象即可，具体代码如下。

@Override
public ConcretePrototype clone() {
    return instance;
}
原型模式在源码中的应用

ArrayList实现了 Cloneable 接口，并重写了clone方法，源码如下：

public Object clone() {
    try {
        @SuppressWarnings("unchecked")
        ArrayList<E> v = (ArrayList<E>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        throw new InternalError();
    }
}

从以上代码可以看出，clone() 方法只是将 List 中的元素循环遍历了一遍。假如集合a中对象是引用类型，那么现在通过ArrayList中的clone对象复制，会是深拷贝还是浅拷贝？

仿照上述的代码示例，再新增一个类，类中使用ArrayList 引用变量，然后通过clone的方式，复制集合中的内容；代码如下：

public class DeepPrototypeList implements Cloneable,Serializable{
	
	private static final long serialVersionUID = 1L;
	
	private String userName;
	
	private ArrayList<DeepCloneOjb> deepCloneOjbList;
	
	

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	
	public ArrayList<DeepCloneOjb> getDeepCloneOjb() {
		return deepCloneOjbList;
	}

	public void setDeepCloneOjb(ArrayList<DeepCloneOjb> deepCloneOjb) {
		this.deepCloneOjbList = deepCloneOjb;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		//这里完成对基本数据类型(属性)和String的克隆
		Object deep = super.clone(); 
		//对引用类型的属性，进行单独处理
		DeepPrototypeList deepProtoType = (DeepPrototypeList)deep;
		deepProtoType.deepCloneOjbList = (ArrayList<DeepCloneOjb>) ((ArrayList)deepProtoType.deepCloneOjbList).clone();		
		return deepProtoType;
	}
	
  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);
			DeepPrototypeList copyObj = (DeepPrototypeList)ois.readObject();
			
			return copyObj;
			
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			//关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
			System.out.println(e2.getMessage());
			}
		}
	}
	@Override
	public String toString() {
		return "DeepPrototypeList hashcode =  "+hashCode()+", [userName=" + userName + ", deepCloneOjbList=" + deepCloneOjbList + "]";
	}	
}
  • 使用方
public static void main(String[] args) throws CloneNotSupportedException {
		DeepCloneOjb deepCloneOjb = new  DeepCloneOjb();
		deepCloneOjb.setName("deepCloneOjb");
		deepCloneOjb.setAge(10);
        
		ArrayList<DeepCloneOjb> list = new ArrayList<>();
		list.add(deepCloneOjb);
		
		DeepPrototypeList deepPrototypeList =  new DeepPrototypeList();
				deepPrototypeList.setUserName("deepPrototypeList");
		deepPrototypeList.setDeepCloneOjb(list);
		
		System.out.println("源对象 deepPrototypeList=="+deepPrototypeList.toString());
		
		DeepPrototypeList deepPrototypeList2 = (DeepPrototypeList)deepPrototypeList.deepClone();
		System.out.println("序列化方式 deepPrototypeList2=="+deepPrototypeList2.toString());

		DeepPrototypeList deepPrototypeList3 =	(DeepPrototypeList)deepPrototypeList.clone();
		System.out.println("集合提供克隆方法 deepPrototypeList3=="+deepPrototypeList3.toString());
	}

执行结果：

源对象 deepPrototypeList==DeepPrototypeList hashcode =  2018699554, [userName=deepPrototypeList, deepCloneOjbList=[, DeepCloneOjb hashcode = [1311053135 ] , data = [name=deepCloneOjb, age=10]]]
序列化方式 deepPrototypeList2==DeepPrototypeList hashcode =  2065951873, [userName=deepPrototypeList, deepCloneOjbList=[, DeepCloneOjb hashcode = [1791741888 ] , data = [name=deepCloneOjb, age=10]]]
集合提供克隆方法 deepPrototypeList3==DeepPrototypeList hashcode =  1595428806, [userName=deepPrototypeList, deepCloneOjbList=[, DeepCloneOjb hashcode = [1311053135 ] , data = [name=deepCloneOjb, age=10]]]

可以看到，我们使用ArrayList中clone方法克隆，集合中的对象地址还是同一个，那么可以得出结论，ArrayList中的clone方法是浅拷贝。

有没有一直方式，来实现深拷贝，如代码所示，我们可以通过序列化的方式，来实现深拷贝。

✨✨ 欢迎🔔订阅个人的微信公众号 享及时博文更新
个人工作号
✨✨ 个人GitHub地址
GitHub

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值