23种设计模式之原型模式
23种设计模式总篇：https://chenmingyu.top/design/
原型模式
原型模式属于创建型设计模式
定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
原型模式通过克隆一个已经存在的对象实例来返回新的实例，而不是通过new去创建对象，多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；
java中复制对象是通过重写 clone()实现的，原型类需要实现Cloneable接口，否则报CloneNotSupportedException异常
模式类图
角色
- 抽象原型：Prototype，可以为接口或者抽象类，实现了
Cloneable接口，重写了clone()方法，子类只需实现或集成即可拥有克隆功能 - 具体原型：PrototypeA，PrototypeB，实现/集成了Prototype接口的类，拥有克隆方法
- 工厂模式：原型模式常和工厂模式一起使用，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者
优点
- 性能优良，比new一个对象性能好很多
- 不受对象构造函数的约束
模式代码实现
源码地址：https://github.com/mingyuHub/design-patterns
以获取笔对象为例子，结合工厂模式讲解如何使用原型模式，涉及的类：Pen（抽象类），Pencil（铅笔），CarbonPen（碳素笔），PenFactory（工厂类）
抽象原型
抽象类，实现了Cloneable接口，重写了clone()方法
/**
* @author: chenmingyu
* @date: 2019/2/28 09:54
* @description: 抽象原型角色
*/
@Data
public abstract class Pen implements Cloneable{
private String name;
public Pen(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
具体原型
Pencil，继承Pen
/**
* @author: chenmingyu
* @date: 2019/2/28 11:27
* @description: 铅笔
*/
public class Pencil extends Pen{
public Pencil(String name) {
super(name);
}
}
CarbonPen，继承了`Pen
/**
* @author: chenmingyu
* @date: 2019/2/28 11:29
* @description: 碳素笔
*/
public class CarbonPen extends Pen{
public CarbonPen(String name) {
super(name);
}
}
工厂类
简单工厂实现
/**
* @author: chenmingyu
* @date: 2019/2/28 11:32
* @description: 笔生产工厂
*/
public class PenFactory {
/**
* 原型类容器
*/
private static Map<String, Pen> penMap = new Hashtable<>();
/**
* 初始化
*/
public static void init() {
Pen carbonPen = new CarbonPen("碳素笔");
penMap.put(CarbonPen.class.getName(),carbonPen);
Pen pencil = new Pencil("铅笔");
penMap.put(Pencil.class.getName(),pencil);
}
/**
* 通过复制获取实例
* @param className
* @return
* @throws CloneNotSupportedException
*/
public static Pen getPen(Class className) throws CloneNotSupportedException{
Pen cachedShape = penMap.get(className.getName());
return (Pen) cachedShape.clone();
}
}
验证
public static void main(String[] args){
PenFactory.init();
IntStream.range(0,2).forEach(i->{
try {
System.out.println(PenFactory.getPen(CarbonPen.class).getClass());
System.out.println(PenFactory.getPen(Pencil.class).getClass());
System.out.println(" ... ");
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
});
}
输出
class com.example.design.prototype.CarbonPen
class com.example.design.prototype.Pencil
...
class com.example.design.prototype.CarbonPen
class com.example.design.prototype.Pencil
...
浅拷贝和深拷贝
浅拷贝：将一个对象复制后，基本类型会被重新创建，引用类型的对象会把引用拷贝过去，实际上还是指向的同一个对象
深拷贝：将一个对象复制后，基本类型和引用类型的对象都会被重新创建
浅拷贝
举个例子
/**
* @author: chenmingyu
* @date: 2019/2/28 14:53
* @description: 克隆
*/
@Data
public class Clone implements Cloneable{
private CloneA CloneA;
public Clone() {
this.CloneA = new CloneA();
}
@Override
protected Clone clone() throws CloneNotSupportedException {
return (Clone) super.clone();
}
class CloneA{
}
}
验证
public static void main(String[] args) throws CloneNotSupportedException{
Clone clone = new Clone();
Clone clone1 = clone.clone();
System.out.println(clone == clone1);
System.out.println(clone.getCloneA() == clone1.getCloneA());
}
输出
false
true
所以clone()方法是执行的浅拷贝，这个需要在写代码的时候注意一下，浅拷贝是否可以满足需求
深拷贝
深拷贝的实现方案主要有两种
- 引用类型也使用clone()，进行clone的时候，对引用类型在调用一次clone()方法
- 使用序列化，将对象序列化后在反序列化回来，得到新的对象实例
使用序列化实现以下
/**
* @author: chenmingyu
* @date: 2019/2/28 14:53
* @description: 浅克隆
*/
@Data
public class Clone implements Cloneable ,Serializable {
private CloneA CloneA;
public Clone() {
this.CloneA = new CloneA();
}
@Override
protected Clone clone() throws CloneNotSupportedException {
return (Clone) super.clone();
}
/**
* 深拷贝
* @return
* @throws CloneNotSupportedException
*/
protected Clone deepClone() throws CloneNotSupportedException {
Clone clone = null;
try{
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(this);
oos.close();
ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois=new ObjectInputStream(bais);
//生成新的对象实例
clone=(Clone)ois.readObject();
ois.close();
}catch (Exception e){
e.printStackTrace();
}
return clone;
}
class CloneA implements Serializable{
}
}
验证
public static void main(String[] args) throws CloneNotSupportedException{
Clone clone = new Clone();
Clone clone1 = clone.deepClone();
System.out.println(clone == clone1);
System.out.println(clone.getCloneA() == clone1.getCloneA());
}
输出
false
false
在使用原型模式的时候一定要理解什么是浅拷贝和深拷贝，才可以放心的使用原型模式，并且一般都会和工厂模式一起使用
