常用Java设计模式系列（2）- 原型模式

在上篇文章中，我们讲述了最常见也是最简单的单例设计模式<常用Java设计模式系列（1）- 单例模式>，在这篇文章中，我们继续设计模式之旅，来讲第二个比较常见的设计模式，那就是原型模式。

什么是原型模式呢？

原型模式属于对象的创建模式，通过一个原型对象，我们可以创建出更多同类型的对象，避免每次创建同一类型的对象时都是使用new关键字进行创建。

简单原型模式的框架大致如下所示：

从上图可以看出，整个模式中设计及三种角色，分别如下：

（1）客户角色：（提出创建对象的客户类）

（2）抽象原型角色：这是一个抽象角色，一般由一个接口或者抽象类来进行实现

（3）具体原型角色：能被复制的对象，需要实现抽象原型角色中定义的复制自身能力的接口

下面我们简单的通过Java示例代码来进行说明。

package com.majing.test.designpattern.prototype;

import java.io.Serializable;
import java.util.List;

public abstract class Prototype implements Cloneable,Serializable{

	private static final long serialVersionUID = 6373322365181226285L;

	private String name;
	
	private int age;
	
	private List<String> interests;

	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 List<String> getInterests() {
		return interests;
	}

	public void setInterests(List<String> interests) {
		this.interests = interests;
	}

	@Override
	public String toString() {
		return "Prototype [name=" + name + ", age=" + age + ", interests=" + interests + "]";
	}
	
	

}

下面是具体原型类定义：

package com.majing.test.designpattern.prototype;

public class ConcretePrototype1 extends Prototype {

	private static final long serialVersionUID = 1060689305923602305L;

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

下面给出客户角色（也就是使用原型模式提出创建对象请求的类）：

package com.majing.test.designpattern.prototype;

import java.util.ArrayList;
import java.util.List;

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		shallowCopy();
	}
	
	public static void shallowCopy() throws CloneNotSupportedException{
		ConcretePrototype1 concretePrototype1 = new ConcretePrototype1();
		concretePrototype1.setName("majing");
		concretePrototype1.setAge(29);
		List<String> interests = new ArrayList<String>();
		interests.add("军事");
		interests.add("上网");
		concretePrototype1.setInterests(interests);
		
		ConcretePrototype1 copyPrototype = (ConcretePrototype1)concretePrototype1.clone();
		System.out.println("通过原型模式拷贝（浅拷贝）：");
		System.out.println(copyPrototype.getName());
		System.out.println(copyPrototype.getAge());
		System.out.println(copyPrototype.getInterests());
		
		System.out.println("修改原型实例的内容：");
		concretePrototype1.getInterests().remove("上网");
		
		System.out.println("修改后：");
		System.out.println(copyPrototype.getName());
		System.out.println(copyPrototype.getAge());
		System.out.println(copyPrototype.getInterests());
	}
}

运行上面的代码后，我们贴出运行的结果：

从上面的运行结果看，我们可以看到，通过原型对象拷贝出来的对象其实和原对象还是有关联的，对原型对象的修改会影响到通过他复制出来的对象（反之亦然）。这是为什么呢？

其实，还是因为我们这里的实现其实实现的是浅拷贝。

什么是浅拷贝呢？浅拷贝是和深拷贝而言的。对于浅拷贝，Java基础类型会和原型对象保持独立，但是对于引用类型，被拷贝者其实是和拷贝者共同指向同一个引用，其实指向的是同一块堆地址。而对于深拷贝，则会给拷贝者的引用类型重新分配内存空间，被拷贝者其实是和拷贝者中的引用类型指向的是不同的堆空间地址。下面我们给出深拷贝的一种实现，看看效果如何：

package com.majing.test.designpattern.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ConcretePrototype2 extends Prototype {

	private static final long serialVersionUID = -5479395220936927123L;

	@Override
	protected Object clone() throws CloneNotSupportedException {
		try {
			//将对象写到流里
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(bos);
			oos.writeObject(this);
			//从流里读回来
			ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bis);
			return ois.readObject();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
}

这里通过序列化的方式将对象状态先保存，再进行反序列化从而完成新对象的创建。我们稍微修改下之前的客户角色代码：

package com.majing.test.designpattern.prototype;

import java.util.ArrayList;
import java.util.List;

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		deepCopy();
	}
	
	public static void deepCopy() throws CloneNotSupportedException{
		ConcretePrototype2 concretePrototype2 = new ConcretePrototype2();
		concretePrototype2.setName("majing");
		concretePrototype2.setAge(29);
		List<String> interests = new ArrayList<String>();
		interests.add("军事");
		interests.add("上网");
		concretePrototype2.setInterests(interests);
		
		ConcretePrototype2 copyPrototype = (ConcretePrototype2)concretePrototype2.clone();
		System.out.println("通过原型模式拷贝（深拷贝）：");
		System.out.println(copyPrototype.getName());
		System.out.println(copyPrototype.getAge());
		System.out.println(copyPrototype.getInterests());
		
		System.out.println("修改原型实例的内容：");
		concretePrototype2.getInterests().remove("上网");
		
		System.out.println("修改后：");
		System.out.println(copyPrototype.getName());
		System.out.println(copyPrototype.getAge());
		System.out.println(copyPrototype.getInterests());
	}
}

运行后我们得到如下的结果：

从这里我们可以看到，通过深拷贝，被拷贝者和拷贝者两者之间已经完全独立了，不会相互影响。当然这里只是给出一个简单的示例说明，实际使用过程中还要根据实际情况进行适当的调整。

至此，关于原型模式的相关说明已经全部讲述完毕，如果想了解我最新的博文，请关注我的博客，谢谢。如果您愿意打赏我，可扫描下方二维码，对您的打赏我表示感谢。