二十三种设计模式第五篇--原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。
我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

用原型实例来指定创建对的种类，并且通过拷贝这些原型来创建新的对象。

在什么情况下使用原型模式：

1. 在类的初始化消耗的资源非常之多的时候使用
2. 使用new创建一个对象需要非常烦琐的过程
3. 构造函数比较复杂
4. 在循环体中产生大量对象

注意原型模式中有使用克隆操作来实现复制类，但是clone操作又可以分为深克隆和浅克隆之分，既然要用到clone操作，我们知道深拷贝需要实现Cloneable，Serializable两个接口，重写clone方法，并且在java中，我们主要使用的clone操作都是浅拷贝。
其深拷贝具体方法：

1. 实现 Cloneable 接口，递归 clone 引用对象或 new 新对象(类的属性字段未实现 Cloneable 接口)
2. 借助序列化完成深拷贝，如实现 JDK java.io.Serializable 接口、json格式序列化、xml格式序列化等。

原型模式UML图

这里我从软件设计师书本上摘抄到一个例子来介绍：

Prototype模式适用于：

• 当一个系统应该独立于它的产品创建、构成和表示时。
• 当要实例化的类是在运行时刻指定时，例如，通过动态装载。
• 为了避免创建一个与产品类层次平行的工厂类层次时。
• 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们，可能比每次用合适的状态手工实例化该类更方便一些。

原型模式代码

根据上述UML图，我们来具体实现：

public class Main {public static void main(String[] args) {Product product1 = new Product(2023, 5.8);System.out.println(product1.getId() + " " + product1.getPrice());// Product product2 = new Product(2023, 5.8);Product product2 = (Product) product1.Clone();System.out.println(product2.getId() + " " + product2.getPrice());Product product3 = (Product) product1.Clone();System.out.println(product3.getId() + " " + product3.getPrice());}
}

interface Prototype {public Object Clone();
}

class Product implements Prototype {private int id;private double price;//创建无参构造方法public Product() {}//有参构造public Product(int id, double price) {this.id = id;this.price = price;}public int getId() {return id;}public double getPrice() {return price;}@Overridepublic Object Clone() {Product object = new Product();object.id = this.id;object.price = this.price;return object;}
}

通过上述方式，我们就已经简单实现一个原型模式了。

第二个实例实现原型模式

这个图应该看得懂吧?孙大圣以及金箍棒，首先孙悟空是猴子，他有个绰号叫齐天大圣，我们在齐天大圣里边实现原型模式。

public class Monkey {public int height;public int weight;   //基本型数据public Date birthday;}

创建金箍棒，实现序列化接口

//金箍棒
public class JinGuBang implements Serializable {public float h = 100;public float d = 10;//金箍棒变大public void big(){this.d *= 2;this.h *= 2;}
//金箍棒变小public void small(){this.d /= 2;this.h /= 2;}@Overridepublic String toString() {return "JinGuBang{" +"h=" + h +", d=" + d +'}';}
}

public class QiTianDaSheng extends Monkey implements Cloneable,Serializable {public JinGuBang jinGuBang;Object obj;//先初始化一些数值public  QiTianDaSheng(){//只是初始化this.birthday = new Date();this.jinGuBang = new JinGuBang();}//将原来的浅克隆改为深克隆.@Overrideprotected Object clone() throws CloneNotSupportedException {//  return super.clone();// return this.shallowClone(this);   //浅克隆return this.deepClone();   //深克隆}//利用对象流完成深克隆,       还有一种麻烦的实现: 递 归./*深复制把要复制的对象所引用的对象都复制了一遍。拷贝需要实现Cloneable, Serializable两个接口，重写clone方法*/public Object deepClone(){try{ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(this);oos.flush();ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);QiTianDaSheng copy = (QiTianDaSheng)ois.readObject();copy.birthday = new Date();return copy;}catch (Exception e){e.printStackTrace();return null;}}//浅克隆public QiTianDaSheng shallowClone(QiTianDaSheng target){QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();qiTianDaSheng.height = target.height;qiTianDaSheng.weight = target.weight;//浅克隆对对象类型的数据只克隆了地址，没有复制值qiTianDaSheng.jinGuBang = target.jinGuBang;    //对于引用型的数据，只克隆了地址.qiTianDaSheng.birthday = new Date();return  qiTianDaSheng;}@Overridepublic String toString() {return "QiTianDaSheng{" +"jinGuBang=" + jinGuBang +", height=" + height +", weight=" + weight +", birthday=" + birthday +'}';}
}

public class DeepCloneTest {public static void main(String[] args) {QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();try {QiTianDaSheng clone = (QiTianDaSheng)qiTianDaSheng.clone();System.out.println(   "克隆:"+   clone);System.out.println(     qiTianDaSheng );//原型模式下对象创建了两次,但值 一样.System.out.println(   "hashcode:  " +  clone.hashCode()+"\t"+ qiTianDaSheng.hashCode() );//jingubang是一个引用型， 对于浅克隆.System.out.println(  "jingubang的hashcode: "+ clone.jinGuBang.hashCode() +"\t"+   qiTianDaSheng.jinGuBang.hashCode() );//  System.out.println("判断克隆结果,如两个jinGuBang对象相同，则为浅克隆，如不同，则为深克隆：" + (qiTianDaSheng.jinGuBang == clone.jinGuBang));} catch (Exception e) {e.printStackTrace();}//        QiTianDaSheng q = new QiTianDaSheng();
//        QiTianDaSheng n = q.shallowClone(q);
//        System.out.println("浅克隆：" + (q.jinGuBang == n.jinGuBang));}
}

至此，我们通过齐天大圣类来完成类的克隆，并且实现序列化接口和Cloneable接口，完成深克隆操作，来实现原型模式。如果以上介绍还不是看的很爽，那我们接着看。

第三个实例实现原型模式

老样子，先摆上UML图。

创建一个shape类作为父类

public abstract class Shape implements Cloneable {private String id;protected String type;public List values;//注意关键是在 这里，应该重写一个clone()方法,提供对象克隆功能。默认是一个浅克隆.@Overridepublic Object clone() {Object clone = null;try {clone = super.clone();    ///} catch (CloneNotSupportedException e) {e.printStackTrace();}return clone;}abstract void draw();public void setValues(List values) {this.values = values;}public List getValues() {return values;}public String getType(){return type;}public String getId() {return id;}public void setId(String id) {this.id = id;}
}

创建子类

public class Circle extends Shape implements Cloneable{public Circle(){type = "Circle";}@Overridepublic void draw() {System.out.println("Inside Circle::draw() method.");}
}

public class Rectangle extends Shape {public Rectangle(){type = "Rectangle";}@Overridepublic void draw() {System.out.println("Inside Rectangle::draw() method.");}
}

public class Square extends Shape {public Square(){type = "Square";}@Overridepublic void draw() {System.out.println("Inside Square::draw() method.");}
}

创建好克隆类

public class ShapeCache {//用一个容器存好原始对象.private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();//如果要获取某个对象的一个拷贝，则从容器中取出原型， 再调用原型的拷贝方法public static Shape getShape(String shapeId) {Shape cachedShape = shapeMap.get(shapeId);return (Shape) cachedShape.clone();}// 对每种形状都运行数据库查询，并创建该形状// shapeMap.put(shapeKey, shape);// 例如，我们要添加三种形状( 这就是三种形状的原型, 以用于后期的拷贝 )public static void loadCache() {Circle circle = new Circle();circle.setId("1");List list=new ArrayList();list.add(1);list.add(2);circle.setValues(  list   );shapeMap.put(circle.getId(),circle);Square square = new Square();square.setId("2");shapeMap.put(square.getId(),square);Rectangle rectangle = new Rectangle();rectangle.setId("3");shapeMap.put(rectangle.getId(),rectangle);}
}

创建测试类

public class PrototypePatternDemo {public static void main(String[] args) {ShapeCache.loadCache();  //首先加载 类的原型实例.//以下操作获取原型的克隆对象.Shape clonedShape = (Shape) ShapeCache.getShape("1");//在这里可以对这个对象进行值 的设置，想像一下，如果这个对象有多个值 要设置的话，避免了创建对象的消耗.System.out.println("Shape : " + clonedShape.getType()+"  "+clonedShape);Shape cs2 = (Shape) ShapeCache.getShape("1");//在这里可以对这个对象进行值 的设置，想像一下，如果这个对象有多个值 要设置的话，避免了创建对象的消耗.cs2.setId("333");// *******注意两次获取的对象不同,这叫原型模式System.out.println("Shape : " + cs2.getType()+"   "+cs2 );Shape clonedShape2 = (Shape) ShapeCache.getShape("2");System.out.println("Shape : " + clonedShape2.getType());        Shape clonedShape3 = (Shape) ShapeCache.getShape("3");System.out.println("Shape : " + clonedShape3.getType());//默认情况下: clone()是一个浅克隆.System.out.println(  "两次产生的对象中的 引用类型的属性值(地址) 是相等的:"+  ( clonedShape.values==cs2.values )  );//这说明： 当对clonedShape中的 values进行修改时， cs2.values也会变，这肯定是不被 允许 .clonedShape.values.add("abc");  //  cs2.values也会变for(   Object o:cs2.values){System.out.println(   o );}// 下面改为深克隆来完成对对象属性值 的复制.}
}