Java設(shè)計模式之原型模式詳解

更新時間：2021年05月06日 11:40:24 作者：小小魚兒小小林

這篇文章主要介紹了Java設(shè)計模式之原型模式詳解,文中有非常詳細的代碼示例,對正在學(xué)習(xí)java的小伙伴們有非常好的幫助,需要的朋友可以參考下

一、前言

原型模式是一種比較簡單的模式，也非常容易理解，實現(xiàn)一個接口，重寫一個方法即完成了原型模式。在實際應(yīng)用中，原型模式很少單獨出現(xiàn)。經(jīng)常與其他模式混用，他的原型類Prototype也常用抽象類來替代。

該模式的思想就是將一個對象作為原型，對其進行復(fù)制、克隆，產(chǎn)生一個和原對象類似的新對象。在Java中，復(fù)制對象是通過clone()實現(xiàn)的，先創(chuàng)建一個原型類，通過實現(xiàn)Cloneable 接口

public class Prototype implements Cloneable {  
 
		public Object clone() throws CloneNotSupportedException {  
			Prototype proto = (Prototype) super.clone();  
			return proto;  
		}  
	}

只需要實現(xiàn)Cloneable接口，覆寫clone方法，此處clone方法可以改成任意的名稱，因為Cloneable接口是個空接口，你可以任意定義實現(xiàn)類的方法名，如cloneA或者cloneB，因為此處的重點是super.clone()這句話，super.clone()調(diào)用的是Object的clone()方法，而在Object類中，clone()是native的，說明這個方法實現(xiàn)并不是使用java語言，是底層C實現(xiàn)阿達

至于cloneA或者cloneB名字可以任意取，是因為要你主動去調(diào)用的，所以你名字取成什么，你調(diào)用的時候就調(diào)用該名字就可以了

二、優(yōu)點及適用場景

使用原型模式創(chuàng)建對象比直接new一個對象在性能上要好的多，因為上面我也提到過，Object類的clone()是native的，它直接操作內(nèi)存中的二進制流，特別是復(fù)制大對象時，性能的差別非常明顯。

使用原型模式的另一個好處是簡化對象的創(chuàng)建，使得創(chuàng)建對象就像我們在編輯文檔時的復(fù)制粘貼一樣簡單。

因為以上優(yōu)點，所以在需要重復(fù)地創(chuàng)建相似對象時可以考慮使用原型模式。比如需要在一個循環(huán)體內(nèi)創(chuàng)建對象，假如對象創(chuàng)建過程比較復(fù)雜或者循環(huán)次數(shù)很多的話，使用原型模式不但可以簡化創(chuàng)建過程，而且可以使系統(tǒng)的整體性能提高很多。

三、原型模式的注意事項

使用原型模式復(fù)制對象不會調(diào)用類的構(gòu)造方法。因為對象的復(fù)制是通過調(diào)用Object類的clone()來完成的，它直接在內(nèi)存中復(fù)制數(shù)據(jù)，因此不會調(diào)用到類的構(gòu)造方法。不但構(gòu)造方法中的代碼不會執(zhí)行，甚至連訪問權(quán)限都對原型模式無效。

說到這里，就得順便提一下單例模式，在單例模式中，只要將構(gòu)造方法的訪問權(quán)限設(shè)置為private型，就可以實現(xiàn)單例。但是clone方法直接無視構(gòu)造方法的權(quán)限，所以，單例模式與原型模式是沖突的，在使用時要特別注意。

四、淺復(fù)制和深復(fù)制

另外還得知道兩個特別重要的概念 : 淺復(fù)制深復(fù)制

淺復(fù)制：將一個對象復(fù)制后，基本數(shù)據(jù)類型的變量都會重新創(chuàng)建，而數(shù)組、容器對象、引用對象等都不會拷貝，指向的還是原對象所指向的地址。淺拷貝實現(xiàn) Cloneable，重寫clone方法

深復(fù)制：將一個對象復(fù)制后，不論是基本數(shù)據(jù)類型還有引用類型，都是重新創(chuàng)建的。簡單來說，就是深復(fù)制進行了完全徹底的復(fù)制，而淺復(fù)制不徹底。深拷貝是通過實現(xiàn) Serializable 讀取二進制流

五、淺復(fù)制demo演示

首先我們創(chuàng)建一個抽象原型類 Animal.class，實現(xiàn)了Cloneable接口，并且重寫了clone方法

package cn.zygxsq.design.module.prototypePattern;
 
/**
 * Created by yjl on 2021/4/30.
 * 動物類
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public abstract class Animal implements Cloneable{
    private String id;
    public String name;
 
    abstract void shout();
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    /**
     * 淺復(fù)制
     */
    public Object clone() throws CloneNotSupportedException {
        Animal clone = (Animal) super.clone();
        return clone;
    }
}

再創(chuàng)建兩個實現(xiàn)類

Dog.class 和Cat.class

package cn.zygxsq.design.module.prototypePattern;
 
/**
 * Created by yjl on 2021/4/30.
 */
public class Dog extends Animal {
    public Dog(){
        name = "狗狗";
    }
 
    @Override
    public void shout() {
        System.out.println("我的叫聲是：汪汪汪");
    }
}

package cn.zygxsq.design.module.prototypePattern;
 
/**
 * Created by yjl on 2021/4/30.
 */
public class Cat extends Animal {
    public Cat(){
        name = "貓貓";
    }
 
    @Override
    public void shout() {
        System.out.println("我的叫聲是：喵喵喵");
    }
}

然后創(chuàng)建一個數(shù)據(jù)緩存類，用戶存儲從數(shù)據(jù)庫中獲取到的大對象數(shù)據(jù)或者曾經(jīng)使用過的大對象數(shù)據(jù)

以后下一次想要再次對這個對象數(shù)據(jù)操作的時候，直接從緩存里獲取并且clone一個

package cn.zygxsq.design.module.prototypePattern;
 
import com.google.common.collect.Maps;
import org.springframework.beans.factory.InitializingBean;
 
import java.util.HashMap;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentMap;
 
/**
 * Created by yjl on 2021/4/30.
 * 緩存類 用于加載一些數(shù)據(jù)庫的緩存的數(shù)據(jù)
 */
public class DataCache /*implements InitializingBean*/{
    //正常的情況是 實現(xiàn) InitializingBean ，用于web服務(wù)啟動的時候加載數(shù)據(jù)
    // 這里測試由于不是web服務(wù)，所以就模擬加載數(shù)據(jù)
 
    private static ConcurrentMap<String, Animal> animalCache = Maps.newConcurrentMap();
 
    public static Animal getAnimal(String id) throws Exception{
        Animal cache = animalCache.get(id);
        return (Animal) cache.clone();
    }
 
    public static void init(){
        Dog dog = new Dog();
        String dogid = "111";
        dog.setId(dogid);
        animalCache.put(dogid,dog);
 
        Dog dog2 = new Dog();
        String dogid2 = "222";
        dog2.setId(dogid2);
        animalCache.put(dogid2,dog2);
 
        Cat cat = new Cat();
        String catid = "333";
        cat.setId(catid);
        animalCache.put(catid,cat);
 
    }
}

最后咱們開始測試

先是從數(shù)據(jù)庫里加載緩存，然后要從緩存里獲取數(shù)據(jù)，并且的到的是一個個clone出來的對象

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 測試主類 淺復(fù)制
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public class TestPrototype {
    public static void main(String[] args) {
        DataCache.init(); // 模擬加載數(shù)據(jù)到緩存中
 
        try {
            Animal animal = DataCache.getAnimal("111");
            System.out.println(animal.getName()+"---"+JSON.toJSONString(animal));
 
            Animal animal222 = DataCache.getAnimal("222");
            System.out.println(animal222.getName()+"---"+JSON.toJSONString(animal222));
 
            Animal animal333 = DataCache.getAnimal("333");
            System.out.println(animal333.getName()+"---"+JSON.toJSONString(animal333));
 
            animal.shout();
            animal222.shout();
            animal333.shout();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
 
    }
}

運行結(jié)果：

小伙伴們看的時候，好像沒什么問題，確實沒什么問題，但是細細一看，還是有一定的問題的

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 淺復(fù)制遇到的問題
 */
public class TestCloneProblem {
 
    public static void main(String[] args) {
        //做完TestPrototype的main方法后，好像覺得淺復(fù)制沒有什么問題
        //那么可以看一下下面的a1的name 和 克隆后的name指向的是同一個地址
        DataCache.init(); // 模擬加載數(shù)據(jù)到緩存中
 
        try {
            Animal a1 = DataCache.getAnimal("111");
            Animal a2 = (Animal)a1.clone();
            System.out.println(a1==a2);
            System.out.println(a1.name == a2.name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
}

運行結(jié)果：

大家踩一下 a1的name 和克隆后的name是什么樣的關(guān)系呢

大家可以看到，a1的name和a2的name是一樣的，由于他們的類型是String，所以他們指向的是同一個地址，名稱為“狗狗”的引用地址，大概的樣子可以看下圖

那怎么樣才能不讓a1.name 和a2.name不相同呢，也就是完完全全的復(fù)制，這個就得用到深復(fù)制了

深復(fù)制其實用到的就是流復(fù)制

可以在clone()的方法定義一個深復(fù)制的方法，比如deepClone()

六、深復(fù)制demo演示

記住，深復(fù)制的時候，方法一定得實現(xiàn)可序列化，Serializable

package cn.zygxsq.design.module.prototypePattern;
 
import java.io.*;
 
/**
 * Created by yjl on 2021/4/30.
 * 動物類
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public abstract class Animal implements Cloneable, Serializable{
    private String id;
    public String name;
 
    abstract void shout();
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    /**
     * 淺復(fù)制
     */
    public Object clone() throws CloneNotSupportedException {
        Animal clone = (Animal) super.clone();
        return clone;
    }
 
 
    /**
     * 深復(fù)制
     */
    public Object deepClone() {
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            // 序列化
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);/*將當(dāng)前對象以對象流的方式輸出*/
            //反序列化
            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            Animal deepProtoType = (Animal) objectInputStream.readObject();
            return deepProtoType;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                byteArrayOutputStream.close();
                objectOutputStream.close();
                byteArrayInputStream.close();
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
 
        }
 
    }
}

測試一下結(jié)果

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 測試主類 深復(fù)制
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public class TestPrototypeDeepClone {
    public static void main(String[] args) {
        DataCache.init(); // 模擬加載數(shù)據(jù)到緩存中
 
        try {
            Animal a1 = DataCache.getAnimal("111");
            Animal a2 = (Animal)a1.deepClone();
            System.out.println(a1==a2);
            System.out.println(a1.name == a2.name);
            System.out.println(a1.name);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
 
    }
}

運行結(jié)果：