Java設計模式之原型模式

​

一、概述

原型模式（Prototype Pattern）用于建立重複的對象，同時又能保證性能。它屬于

建立型

設計模式，它提供了一種建立對象的最佳方法。

這種模式是實作了一個原型接口，該接口用于建立目前對象的克隆。當直接建立對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的資料庫操作之後被建立。我們可以緩存該對象，在下一個請求時傳回它的克隆，在需要的時候更新資料庫，以此來減少資料庫調用。

二、介紹

意圖：用原型執行個體指定建立對象的種類，并且通過拷貝這些原型建立新的對象。

主要解決：在運作期建立和删除模型。

何時使用：

1. 當一個系統應該獨立于它的産品建立，構成和表示時。
2. 當要執行個體化的類是在運作時指定時，例如，通過動态裝載。
3. 為了避免一個與産品類層次平行的工廠類層次時。
4. 當一個類的執行個體隻能有幾個不同狀态組合中的一種時。建立相應數目的原型并克隆它們可能比每次用何時的狀态手工執行個體化該類更友善一些。

如何解決：利用已有的一個原型對象，快速地生成和原型對象一樣的執行個體。

1. 實作克隆操作，繼承

   Cloneable

   ，重寫

   clone()

   方法。
2. 原型模式同樣用于隔離類對象的使用者和具體類型（易變類）之間的耦合關系，它同樣要求這些“易變類”擁有穩定的接口。

應用執行個體：細胞分裂；Object的

clone()

優點：性能提高；逃避構造函數的限制。

缺點：

1. 配備克隆方法需要對類的功能進行通盤考慮，這對于全新的類不是很難，但對于已有的類不一定容易，特别當一個類引用不支援串行化的間接對象，或者引用含有循環結構的時候。
2. 必須實作

   Cloneable

   接口。

使用場景：

1. 資源優化場景。
2. 類初始化需要消耗非常多的資源，這個資源包括資料、硬體資源等。
3. 性能和安全要求的場景。
4. 通過new産生一個對象需要非常繁瑣的資料準備或通路權限，則可以使用原型模式。
5. 一個對象多個修改者的場景。
6. 一個對象需要提供給其他對象通路，而且各個調用者可能都需要修改其值時，可以考慮使用原型模式拷貝多個對象供調用者使用。
7. 在實際項目中，原型模式很少單獨出現，一般是和工廠模式一起出現，通過

   clone

   方法建立一個對象，然後由工廠方法提供給調用者。

注意事項：與通過對一個類進行執行個體化來構造新對象不同的是，原型模式是通過拷貝一個現有對象生成新對象的。淺拷貝實作

Cloneable

，重寫，深拷貝是通過實作

Serializable

讀取二進制流。

三、實作

我們将建立一個抽象類 Shape 和擴充了 Shape 類的實體類。下一步是定義類ShapeCache，該類把shape對象存儲在一個

Hashtable

中，并在請求的時候傳回他們的克隆。具體UML圖如下：

• 步驟1

  建立一個實作了

  Cloneable

  接口的抽象類 Shape：

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
public class Rectangle extends Shape {
 
   public Rectangle(){
     type = "Rectangle";
   }
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

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

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

• 步驟3

  建立一個類，從資料庫擷取實體類，并把它們存儲在一個

  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();
   }
 
   // 對每種形狀都運作資料庫查詢，并建立該形狀
   // 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

  測試類：

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());        
   }
}           

輸出結果：

Shape : Circle

Shape : Square

Shape : Rectangle