在閻巨集博士的《JAVA與模式》一書中開頭是這樣描述原型（Prototype）模式的：

　　原型模式屬於物件的建立模式。通過給出一個原型物件來指明所有建立的物件的型別，然後用複製這個原型物件的辦法創建出更多同類型的物件。這就是選型模式的用意。

原型模式的結構

　　原型模式要求物件實現一個可以“克隆”自身的介面，這樣就可以通過複製一個例項物件本身來建立一個新的例項。這樣一來，通過原型例項建立新的物件，就不再需要關心這個例項本身的型別，只要實現了克隆自身的方法，就可以通過這個方法來獲取新的物件，而無須再去通過new來建立。

　　原型模式有兩種表現形式：（1）簡單形式、（2）登記形式，這兩種表現形式僅僅是原型模式的不同實現。

簡單形式的原型模式

　　　　這種形式涉及到三個角色：

　　（1）客戶(Client)角色：客戶類提出建立物件的請求。

　　（2）抽象原型(Prototype)角色：這是一個抽象角色，通常由一個Java介面或Java抽象類實現。此角色給出所有的具體原型類所需的介面。

　　（3）具體原型（Concrete Prototype）角色：被複制的物件。此角色需要實現抽象的原型角色所要求的介面。

原始碼

　　抽象原型角色

1 public interface Prototype{
2     /**
3      * 克隆自身的方法
4      * @return 一個從自身克隆出來的物件
5      */
 

6     public Object clone();
7 }

具體原型角色

1 public class ConcretePrototype1 implements Prototype {
2     public Prototype clone(){
3         //最簡單的克隆，新建一個自身物件，由於沒有屬性就不再複製值了
4         Prototype prototype = new ConcretePrototype1();
5         return prototype;
6     }
7 }

1 public class ConcretePrototype2 implements
 
 Prototype {
2     public Prototype clone(){
3         //最簡單的克隆，新建一個自身物件，由於沒有屬性就不再複製值了
4         Prototype prototype = new ConcretePrototype2();
5         return prototype;
6     }
7 }

客戶端角色

 1 public class Client {
 2     /**
 3      * 持有需要使用的原型介面物件
 4      */
 5     private Prototype prototype;
 6     /**
 7      * 構造方法，傳入需要使用的原型介面物件
 8      */
 9     public Client(Prototype prototype){
10         this.prototype = prototype;
11     }
12     public void operation(Prototype example){
13         //需要建立原型介面的物件
14         Prototype copyPrototype = prototype.clone();
15         
16     }
17 }

登記形式的原型模式

　　作為原型模式的第二種形式，它多了一個原型管理器(PrototypeManager)角色，該角色的作用是：建立具體原型類的物件，並記錄每一個被建立的物件。

原始碼

　　抽象原型角色

1 public interface Prototype{
2     public Prototype clone();
3     public String getName();
4     public void setName(String name);
5 }

具體原型角色

 1 public class ConcretePrototype1 implements Prototype {
 2     private String name;
 3     public Prototype clone(){
 4         ConcretePrototype1 prototype = new ConcretePrototype1();
 5         prototype.setName(this.name);
 6         return prototype;
 7     }
 8     public String toString(){
 9         return "Now in Prototype1 , name = " + this.name;
10     }
11     @Override
12     public String getName() {
13         return name;
14     }
15 
16     @Override
17     public void setName(String name) {
18         this.name = name;
19     }
20 }

 1 public class ConcretePrototype2 implements Prototype {
 2     private String name;
 3     public Prototype clone(){
 4         ConcretePrototype2 prototype = new ConcretePrototype2();
 5         prototype.setName(this.name);
 6         return prototype;
 7     }
 8     public String toString(){
 9         return "Now in Prototype2 , name = " + this.name;
10     }
11     @Override
12     public String getName() {
13         return name;
14     }
15 
16     @Override
17     public void setName(String name) {
18         this.name = name;
19     }
20 }

原型管理器角色保持一個聚集，作為對所有原型物件的登記，這個角色提供必要的方法，供外界增加新的原型物件和取得已經登記過的原型物件。

 1 public class PrototypeManager {
 2     /**
 3      * 用來記錄原型的編號和原型例項的對應關係
 4      */
 5     private static Map<String,Prototype> map = new HashMap<String,Prototype>();
 6     /**
 7      * 私有化構造方法，避免外部建立例項
 8      */
 9     private PrototypeManager(){}
10     /**
11      * 向原型管理器裡面新增或是修改某個原型註冊
12      * @param prototypeId 原型編號
13      * @param prototype    原型例項
14      */
15     public synchronized static void setPrototype(String prototypeId , Prototype prototype){
16         map.put(prototypeId, prototype);
17     }
18     /**
19      * 從原型管理器裡面刪除某個原型註冊
20      * @param prototypeId 原型編號
21      */
22     public synchronized static void removePrototype(String prototypeId){
23         map.remove(prototypeId);
24     }
25     /**
26      * 獲取某個原型編號對應的原型例項
27      * @param prototypeId    原型編號
28      * @return    原型編號對應的原型例項
29      * @throws Exception    如果原型編號對應的例項不存在，則丟擲異常
30      */
31     public synchronized static Prototype getPrototype(String prototypeId) throws Exception{
32         Prototype prototype = map.get(prototypeId);
33         if(prototype == null){
34             throw new Exception("您希望獲取的原型還沒有註冊或已被銷燬");
35         }
36         return prototype;
37     }
38 }

客戶端角色

 1 public class Client {
 2     public static void main(String[]args){
 3         try{
 4             Prototype p1 = new ConcretePrototype1();
 5             PrototypeManager.setPrototype("p1", p1);
 6             //獲取原型來建立物件
 7             Prototype p3 = PrototypeManager.getPrototype("p1").clone();
 8             p3.setName("張三");
 9             System.out.println("第一個例項：" + p3);
10             //有人動態的切換了實現
11             Prototype p2 = new ConcretePrototype2();
12             PrototypeManager.setPrototype("p1", p2);
13             //重新獲取原型來建立物件
14             Prototype p4 = PrototypeManager.getPrototype("p1").clone();
15             p4.setName("李四");
16             System.out.println("第二個例項：" + p4);
17             //有人登出了這個原型
18             PrototypeManager.removePrototype("p1");
19             //再次獲取原型來建立物件
20             Prototype p5 = PrototypeManager.getPrototype("p1").clone();
21             p5.setName("王五");
22             System.out.println("第三個例項：" + p5);
23         }catch(Exception e){
24             e.printStackTrace();
25         }
26     }
27 }

兩種形式的比較

　　簡單形式和登記形式的原型模式各有其長處和短處。

　　如果需要建立的原型物件數目較少而且比較固定的話，可以採取第一種形式。在這種情況下，原型物件的引用可以由客戶端自己儲存。

　　如果要建立的原型物件數目不固定的話，可以採取第二種形式。在這種情況下，客戶端不儲存對原型物件的引用，這個任務被交給管理員物件。在複製一個原型物件之前，客戶端可以檢視管理員物件是否已經有一個滿足要求的原型物件。如果有，可以直接從管理員類取得這個物件引用；如果沒有，客戶端就需要自行復制此原型物件。

Java中的克隆方法

　　Java的所有類都是從java.lang.Object類繼承而來的，而Object類提供protected Object clone()方法對物件進行復制，子類當然也可以把這個方法置換掉，提供滿足自己需要的複製方法。物件的複製有一個基本問題，就是物件通常都有對其他的物件的引用。當使用Object類的clone()方法來複制一個物件時，此物件對其他物件的引用也同時會被複制一份

　　Java語言提供的Cloneable介面只起一個作用，就是在執行時期通知Java虛擬機器可以安全地在這個類上使用clone()方法。通過呼叫這個clone()方法可以得到一個物件的複製。由於Object類本身並不實現Cloneable介面，因此如果所考慮的類沒有實現Cloneable介面時，呼叫clone()方法會丟擲CloneNotSupportedException異常。

克隆滿足的條件

　　clone()方法將物件複製了一份並返還給呼叫者。所謂“複製”的含義與clone()方法是怎麼實現的。一般而言，clone()方法滿足以下的描述：

　　（1）對任何的物件x，都有：x.clone()!=x。換言之，克隆物件與原物件不是同一個物件。

　　（2）對任何的物件x，都有：x.clone().getClass() == x.getClass()，換言之，克隆物件與原物件的型別一樣。

　　（3）如果物件x的equals()方法定義其恰當的話，那麼x.clone().equals(x)應當成立的。

　　在JAVA語言的API中，凡是提供了clone()方法的類，都滿足上面的這些條件。JAVA語言的設計師在設計自己的clone()方法時，也應當遵守著三個條件。一般來說，上面的三個條件中的前兩個是必需的，而第三個是可選的。

淺克隆和深克隆

　　無論你是自己實現克隆方法，還是採用Java提供的克隆方法，都存在一個淺度克隆和深度克隆的問題。

• 　　淺度克隆

　　只負責克隆按值傳遞的資料（比如基本資料型別、String型別），而不復制它所引用的物件，換言之，所有的對其他物件的引用都仍然指向原來的物件。

• 　　深度克隆

　　除了淺度克隆要克隆的值外，還負責克隆引用型別的資料。那些引用其他物件的變數將指向被複制過的新物件，而不再是原有的那些被引用的物件。換言之，深度克隆把要複製的物件所引用的物件都複製了一遍，而這種對被引用到的物件的複製叫做間接複製。

　　深度克隆要深入到多少層，是一個不易確定的問題。在決定以深度克隆的方式複製一個物件的時候，必須決定對間接複製的物件時採取淺度克隆還是繼續採用深度克隆。因此，在採取深度克隆時，需要決定多深才算深。此外，在深度克隆的過程中，很可能會出現迴圈引用的問題，必須小心處理。

利用序列化實現深度克隆

　　把物件寫到流裡的過程是序列化(Serialization)過程；而把物件從流中讀出來的過程則叫反序列化(Deserialization)過程。應當指出的是，寫到流裡的是物件的一個拷貝，而原物件仍然存在於JVM裡面。

　　在Java語言裡深度克隆一個物件，常常可以先使物件實現Serializable介面，然後把物件（實際上只是物件的拷貝）寫到一個流裡（序列化），再從流裡讀回來（反序列化），便可以重建物件。

 1 public  Object deepClone() throws IOException, ClassNotFoundException{
 2         //將物件寫到流裡
 3         ByteArrayOutputStream bos = new ByteArrayOutputStream();
 4         ObjectOutputStream oos = new ObjectOutputStream(bos);
 5         oos.writeObject(this);
 6         //從流裡讀回來
 7         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 8         ObjectInputStream ois = new ObjectInputStream(bis);
 9         return ois.readObject();
10     }

　這樣做的前提就是物件以及物件內部所有引用到的物件都是可序列化的，否則，就需要仔細考察那些不可序列化的物件可否設成transient，從而將之排除在複製過程之外。

　　淺度克隆顯然比深度克隆更容易實現，因為Java語言的所有類都會繼承一個clone()方法，而這個clone()方法所做的正式淺度克隆。

　　有一些物件，比如執行緒(Thread)物件或Socket物件，是不能簡單複製或共享的。不管是使用淺度克隆還是深度克隆，只要涉及這樣的間接物件，就必須把間接物件設成transient而不予複製；或者由程式自行創建出相當的同種物件，權且當做複製件使用。

孫大聖的身外身法術

　　孫大聖的身外身本領如果在Java語言裡使用原型模式來實現的話，會怎麼樣呢？首先，齊天大聖(The Greatest Sage)即TheGreatestSage類扮演客戶角色。齊天大聖持有一個猢猻（Monkey）的例項，而猢猻就是大聖本尊。Monkey類具有繼承自java.lang.Object的clone()方法，因此，可以通過呼叫這個克隆方法來複制一個Monkey例項。

　　孫大聖本人用TheGreatestSage類代表

 1 public class TheGreatestSage {
 2     private Monkey monkey = new Monkey();
 3     
 4     public void change(){
 5         //克隆大聖本尊
 6         Monkey copyMonkey = (Monkey)monkey.clone();
 7         System.out.println("大聖本尊的生日是：" + monkey.getBirthDate());
 8         System.out.println("克隆的大聖的生日是：" + monkey.getBirthDate());
 9         System.out.println("大聖本尊跟克隆的大聖是否為同一個物件 " + (monkey == copyMonkey));
10         System.out.println("大聖本尊持有的金箍棒 跟 克隆的大聖持有的金箍棒是否為同一個物件？ " + (monkey.getStaff() == copyMonkey.getStaff()));
11     }
12     
13     public static void main(String[]args){
14         TheGreatestSage sage = new TheGreatestSage();
15         sage.change();
16     }
17 }

大聖本尊由Monkey類代表，這個類扮演具體原型角色：

 1 public class Monkey implements Cloneable {
 2     //身高
 3     private int height;
 4     //體重
 5     private int weight;
 6     //生日
 7     private Date birthDate;
 8     //金箍棒
 9     private GoldRingedStaff staff;
10     /**
11      * 建構函式
12      */
13     public Monkey(){
14         this.birthDate = new Date();
15         this.staff = new GoldRingedStaff();
16     }
17     /**
18      * 克隆方法
19      */
20     public Object clone(){
21         Monkey temp = null;
22         try {
23             temp = (Monkey) super.clone();
24         } catch (CloneNotSupportedException e) {
25             // TODO Auto-generated catch block
26             e.printStackTrace();
27         } finally {
28             return temp;
29         }
30     }
31     public int getHeight() {
32         return height;
33     }
34     public void setHeight(int height) {
35         this.height = height;
36     }
37     public int getWeight() {
38         return weight;
39     }
40     public void setWeight(int weight) {
41         this.weight = weight;
42     }
43     public Date getBirthDate() {
44         return birthDate;
45     }
46     public void setBirthDate(Date birthDate) {
47         this.birthDate = birthDate;
48     }
49     public GoldRingedStaff getStaff() {
50         return staff;
51     }
52     public void setStaff(GoldRingedStaff staff) {
53         this.staff = staff;
54     }
55     
56 }

大聖還持有一個金箍棒的例項，金箍棒類GoldRingedStaff:

 1 public class GoldRingedStaff {
 2     private float height = 100.0f;
 3     private float diameter = 10.0f;
 4     /**
 5      * 增長行為，每次呼叫長度和半徑增加一倍
 6      */
 7     public void grow(){
 8         this.diameter *= 2;
 9         this.height *= 2;
10     }
11     /**
12      * 縮小行為，每次呼叫長度和半徑減少一半
13      */
14     public void shrink(){
15         this.diameter /= 2;
16         this.height /= 2;
17     }
18 }

　當執行TheGreatestSage類時，首先建立大聖本尊物件，而後淺度克隆大聖本尊物件。程式在執行時打印出的資訊如下：

　　可以看出，首先，複製的大聖本尊具有和原始的大聖本尊物件一樣的birthDate，而本尊物件不相等，這表明他們二者是克隆關係；其次，複製的大聖本尊所持有的金箍棒和原始的大聖本尊所持有的金箍棒為同一個物件。這表明二者所持有的金箍棒根本是一根，而不是兩根。

　　正如前面所述，繼承自java.lang.Object類的clone()方法是淺克隆。換言之，齊天大聖的所有化身所持有的金箍棒引用全都是指向一個物件的，這與《西遊記》中的描寫並不一致。要糾正這一點，就需要考慮使用深克隆。

　　為做到深度克隆，所有需要複製的物件都需要實現java.io.Serializable介面。

　　孫大聖的原始碼：

 1 public class TheGreatestSage {
 2     private Monkey monkey = new Monkey();
 3     
 4     public void change() throws IOException, ClassNotFoundException{
 5         Monkey copyMonkey = (Monkey)monkey.deepClone();
 6         System.out.println("大聖本尊的生日是：" + monkey.getBirthDate());
 7         System.out.println("克隆的大聖的生日是：" + monkey.getBirthDate());
 8         System.out.println("大聖本尊跟克隆的大聖是否為同一個物件 " + (monkey == copyMonkey));
 9         System.out.println("大聖本尊持有的金箍棒 跟 克隆的大聖持有的金箍棒是否為同一個物件？ " + (monkey.getStaff() == copyMonkey.getStaff()));
10     }
11     
12     public static void main(String[]args) throws IOException, ClassNotFoundException{
13         TheGreatestSage sage = new TheGreatestSage();
14         sage.change();
15     }
16 }

在大聖本尊Monkey類裡面，有兩個克隆方法，一個是clone()，也即淺克隆；另一個是deepClone()，也即深克隆。在深克隆方法裡，大聖本尊物件（一個拷貝）被序列化，然後又被反序列化。反序列化的物件就成了一個深克隆的結果。

 1 public class Monkey implements Cloneable,Serializable {
 2     //身高
 3     private int height;
 4     //體重
 5     private int weight;
 6     //生日
 7     private Date birthDate;
 8     //金箍棒
 9     private GoldRingedStaff staff;
10     /**
11      * 建構函式
12      */
13     public Monkey(){
14         this.birthDate = new Date();
15         staff = new GoldRingedStaff();
16     }
17     /**
18      * 克隆方法
19      */
20     public Object clone(){
21         Monkey temp = null;
22         try {
23             temp = (Monkey) super.clone();
24         } catch (CloneNotSupportedException e) {
25             // TODO Auto-generated catch block
26             e.printStackTrace();
27         } finally {
28             return temp;
29         }
30     }
31     public  Object deepClone() throws IOException, ClassNotFoundException{
32         //將物件寫到流裡
33         ByteArrayOutputStream bos = new ByteArrayOutputStream();
34         ObjectOutputStream oos = new ObjectOutputStream(bos);
35         oos.writeObject(this);
36         //從流裡讀回來
37         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
38         ObjectInputStream ois = new ObjectInputStream(bis);
39         return ois.readObject();
40     }
41     public int getHeight() {
42         return height;
43     }
44     public void setHeight(int height) {
45         this.height = height;
46     }
47     public int getWeight() {
48         return weight;
49     }
50     public void setWeight(int weight) {
51         this.weight = weight;
52     }
53     public Date getBirthDate() {
54         return birthDate;
55     }
56     public void setBirthDate(Date birthDate) {
57         this.birthDate = birthDate;
58     }
59     public GoldRingedStaff getStaff() {
60         return staff;
61     }
62     public void setStaff(GoldRingedStaff staff) {
63         this.staff = staff;
64     }
65     
66 }

　　可以看到，大聖本尊持有一個金箍棒（GoldRingedStaff）的例項。在大聖複製件裡面，此金箍棒例項是原大聖本尊物件所持有的金箍棒物件的一個拷貝。在大聖本尊物件被序列化和反序列化時，它所持有的金箍棒物件也同時被序列化和反序列化，這使得複製的大聖的金箍棒和原大聖本尊物件所持有的金箍棒物件是兩個獨立的物件。

 1 public class GoldRingedStaff implements Serializable{
 2     private float height = 100.0f;
 3     private float diameter = 10.0f;
 4     /**
 5      * 增長行為，每次呼叫長度和半徑增加一倍
 6      */
 7     public void grow(){
 8         this.diameter *= 2;
 9         this.height *= 2;
10     }
11     /**
12      * 縮小行為，每次呼叫長度和半徑減少一半
13      */
14     public void shrink(){
15         this.diameter /= 2;
16         this.height /= 2;
17     }
18 }

　執行結果：

　　從執行的結果可以看出，大聖的金箍棒和他的身外之身的金箍棒是不同的物件。這是因為使用了深克隆，從而把大聖本尊所引用的物件也都複製了一遍，其中也包括金箍棒。

原型模式的優點

　　原型模式允許在執行時動態改變具體的實現型別。原型模式可以在執行期間，由客戶來註冊符合原型介面的實現型別，也可以動態地改變具體的實現型別，看起來介面沒有任何變化，但其實執行的已經是另外一個類例項了。因為克隆一個原型就類似於例項化一個類。

原型模式的缺點

　　原型模式最主要的缺點是每一個類都必須配備一個克隆方法。配備克隆方法需要對類的功能進行通盤考慮，這對於全新的類來說不是很難，而對於已經有的類不一定很容易，特別是當一個類引用不支援序列化的間接物件，或者引用含有迴圈結構的時候。

原文地址：《JAVA與模式》之原型模式