Java設計模式之原型模式詳解

目錄

一、前言

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

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

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

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

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

二、優(yōu)點(diǎn)及適用場(chǎng)景

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

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

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

三、原型模式的注意事項

使用原型模式復制對象不會(huì )調用類(lèi)的構造方法。因為對象的復制是通過(guò)調用Object類(lèi)的clone()來(lái)完成的，它直接在內存中復制數據，因此不會(huì )調用到類(lèi)的構造方法。不但構造方法中的代碼不會(huì )執行，甚至連訪(fǎng)問(wèn)權限都對原型模式無(wú)效。

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

四、淺復制和深復制

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

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

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

五、淺復制demo演示

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

package cn.zygxsq.design.module.prototypePattern;
 
/**
 * Created by yjl on 2021/4/30.
 * 動(dòng)物類(lèi)
 * 原型模式：博文介紹鏈接：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;
    }
 
    /**
     * 淺復制
     */
    public Object clone() throws CloneNotSupportedException {
        Animal clone = (Animal) super.clone();
        return clone;
    }
}

再創(chuàng )建兩個(gè)實(shí)現類(lèi)

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 )建一個(gè)數據緩存類(lèi)，用戶(hù)存儲從數據庫中獲取到的大對象數據或者曾經(jīng)使用過(guò)的大對象數據

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

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.
 * 緩存類(lèi) 用于加載一些數據庫的緩存的數據
 */
public class DataCache /*implements InitializingBean*/{
    //正常的情況是 實(shí)現 InitializingBean ，用于web服務(wù)啟動(dòng)的時(shí)候加載數據
    // 這里測試由于不是web服務(wù)，所以就模擬加載數據
 
    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);
 
    }
}

最后咱們開(kāi)始測試

先是從數據庫里加載緩存，然后要從緩存里獲取數據，并且的到的是一個(gè)個(gè)clone出來(lái)的對象

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 測試主類(lèi) 淺復制
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public class TestPrototype {
    public static void main(String[] args) {
        DataCache.init(); // 模擬加載數據到緩存中
 
        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();
        }
 
 
    }
}

運行結果： 

小伙伴們看的時(shí)候，好像沒(méi)什么問(wèn)題，確實(shí)沒(méi)什么問(wèn)題，但是細細一看，還是有一定的問(wèn)題的

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 淺復制遇到的問(wèn)題
 */
public class TestCloneProblem {
 
    public static void main(String[] args) {
        //做完TestPrototype的main方法后，好像覺(jué)得淺復制沒(méi)有什么問(wèn)題
        //那么可以看一下下面的a1的name 和 克隆后的name指向的是同一個(gè)地址
        DataCache.init(); // 模擬加載數據到緩存中
 
        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();
        }
    }
 
}

運行結果：

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

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

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

深復制其實(shí)用到的就是流復制

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

六、深復制demo演示

記住，深復制的時(shí)候，方法一定得實(shí)現可序列化，Serializable

package cn.zygxsq.design.module.prototypePattern;
 
import java.io.*;
 
/**
 * Created by yjl on 2021/4/30.
 * 動(dòng)物類(lèi)
 * 原型模式：博文介紹鏈接：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;
    }
 
    /**
     * 淺復制
     */
    public Object clone() throws CloneNotSupportedException {
        Animal clone = (Animal) super.clone();
        return clone;
    }
 
 
    /**
     * 深復制
     */
    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);/*將當前對象以對象流的方式輸出*/
            //反序列化
            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();
            }
 
        }
 
    }
}

測試一下結果

package cn.zygxsq.design.module.prototypePattern;
 
import com.alibaba.fastjson.JSON;
 
/**
 * Created by yjl on 2021/4/30.
 * 測試主類(lèi) 深復制
 * 原型模式：博文介紹鏈接：https://blog.csdn.net/qq_27471405/article/details/116309878
 */
public class TestPrototypeDeepClone {
    public static void main(String[] args) {
        DataCache.init(); // 模擬加載數據到緩存中
 
        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();
        }
 
 
    }
}

 運行結果：

這就是深復制和淺復制以及原型模式的使用

到此這篇關(guān)于Java設計模式之原型模式詳解的文章就介紹到這了,更多相關(guān)Java原型模式內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！