原型模式

原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

什么时候使用原型模式

1.对象创建过于复杂：对象创建的时候需要经过计算、排序等操作。
2.对象时间过长：需要查询数据库或者通过rpc调用。
3.对象过多：比如一个集合中有一百万个对象，我现在需要修改这一百万的对象的数据，但是原数据不能动，所以这个时候使用原型模式比较适合。

具体的使用场景还是需要看项目情况而定，不能为了让代码看着高大上而去使用设计模式，比如就只有一个对象的创建（没有任何计算，没有调用数据库和rpc），这个时候如果使用原型模式，虽然效率也会有一点点的提升，但是这样做有点得不偿失，因为还要考虑到代码的可读性和可维护性多重条件。

这么说还是比较空洞，大家可能还是不知道在什么方面使用原型模式，接下来我们将以demo的形式来展示什么是原型模式。

实现

一个抽象的超类，克隆方法在超类中实现，浅复制可以用Object.clone()方法，深复制可以用流处理的方法。具体类继承该超类，就不用实现Clonable接口或Serializable接口，直接复用克隆的方法。

步骤 1

创建一个实现了 Cloneable 接口的抽象类。

Shape.java

public abstract class Shape implements Cloneable {
   
   private String id;
   protected String type;
   
   abstract void draw();
   
   public String getType(){
      return type;
   }
   
   public String getId() {
      return id;
   }
   
   public void setId(String id) {
      this.id = id;
   }
   
   public Object clone() {
      Object clone = null;
      try {
         clone = super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return clone;
   }
}

步骤 2

创建扩展了上面抽象类的实体类。

Rectangle.java

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

Square.java

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

Circle.java

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

步骤 3

创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。

ShapeCache.java

import java.util.Hashtable;
 
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();
   }

//深拷贝
public static Object deepColne(Object obj) {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(obj);
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            return objectInputStream.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
 
   // 对每种形状都运行数据库查询，并创建该形状
   // shapeMap.put(shapeKey, shape);
   // 例如，我们要添加三种形状
   public static void loadCache() {
      Circle circle = new Circle();
      circle.setId("1");
      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);
   }
}

步骤 4

PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆。

PrototypePatternDemo.java

public class PrototypePatternDemo {
   public static void main(String[] args) {
      ShapeCache.loadCache();
 
      Shape clonedShape = (Shape) ShapeCache.getShape("1");
      System.out.println("Shape : " + clonedShape.getType());        
 
      Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
      System.out.println("Shape : " + clonedShape2.getType());        
 
      Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
      System.out.println("Shape : " + clonedShape3.getType());        
   }
}

步骤 5

执行程序，输出结果：

Shape : Circle
Shape : Square
Shape : Rectangle

个人总结

当你需要大量产生一模一样的对象时，如果你new，那恭喜你，你需要的机器资源很多，运维是会对你刮目相看的。而原型模式，就是一种设计，让你拷贝已经在内存中的对象。你可以用clone()方法，但是要注意深度克隆的陷阱。当然你也可以用io流进行序列化，反序列化进行拷贝，也不失是一个好的做法。

抽取变化:变化的是需要拷贝的对象，不变的是克隆的方法，在父类中已经定义好，比如用clone()方法，比如用反序列化方法。