六、簡單又有坑的原型模式

文章目錄

源碼解析

定義

原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。

特點

不需要知道任何的創建細節，並且不調用構造函數

類型

創建型

適用場景

類初始化消耗較多資源
一旦我們創建一個類消耗資源過多的時候，並且還要創建大量的資源多的類的對象的時候
new產生的一個對象需要非常繁瑣的過程（數據準備、訪問權限等）
數據準備也就是給屬性賦值，還有就是關於裏面方法訪問權限等
構造函數比較複雜
循環體中生產大量的對象時

優點

原型模式性能比直接new一個對象性能高
簡化創建過程

缺點

必須配備克隆方法
如果沒有配備Object的clone方法的話，這個模式也不會生效，這個模式的核心就是克隆方法。通過方法進行對象的拷貝。java提供了一個cloneable的接口來標識這個對象是可拷貝的，爲什麼要標識呢？在jvm中具有這個標識的對象纔有可能被拷貝，是有可能被拷貝，怎麼樣才能一定被拷貝呢？我們還要覆蓋Object的克隆方法，所以這個缺點必須配備clone方法
對克隆複雜對象或對克隆出的對象進行復雜改造時，容易引入風險
深拷貝、淺拷貝要運用得當
在對複雜對象進行深拷貝和淺拷貝時候，一定要運用得當，否則很容易引入風險，在對複雜的對象進行改造時候，很容易引入風險的

擴展

深克隆
對於引用類型，如果需要它們指向不同的對象，我們一定要使深克隆，而深克隆對於某一個對象的引用類型的時候，我們要顯式的去寫對於那個屬性進行深克隆
淺克隆
實現比較簡單

coding

我們有個視頻網站經常給學生髮中獎的郵件，代碼如下

public class Mail {
    private String name;
    private String emailAddress;
    private String content;
    public Mail(){
        System.out.println("Mail class Constructor");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

public class MailUtil {
    public static void sendMail(Mail mail){
        String outputContent = "向{0}同學，郵件地址：{1}，郵件內容{2}發送郵件成功";
        System.out.println(MessageFormat.format(outputContent,mail.getName(),mail.getEmailAddress(),mail.getContent()));
    }
    public static void saveOriginMailRecord(Mail mail){
        System.out.println("存儲originMail記錄，originMail:"+mail.getContent());
    }
}

應用類

public class Test {
    public static void main(String[] args) {
        Mail mail=new Mail();
        mail.setContent("初始化模板");

        for(int i=0;i<10;i++){
            mail.setName("姓名"+i);
            mail.setEmailAddress("姓名"+i+"@imooc.com");
            mail.setContent("恭喜您，此次慕課網活動中獎了");
            MailUtil.sendMail(mail);
        }
        MailUtil.saveOriginMailRecord(mail);
    }
}

運行結果

Mail class Constructor
向姓名0同學，郵件地址：姓名0@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名1同學，郵件地址：姓名1@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名2同學，郵件地址：姓名2@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名3同學，郵件地址：姓名3@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名4同學，郵件地址：姓名4@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名5同學，郵件地址：姓名5@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名6同學，郵件地址：姓名6@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名7同學，郵件地址：姓名7@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名8同學，郵件地址：姓名8@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
向姓名9同學，郵件地址：姓名9@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
存儲originMail記錄，originMail:恭喜您，此次慕課網活動中獎了

目標類實現克隆接口原型模式

我們假設這個mail對象的創建、賦值是很耗性能的，在這個循環中又產生大量的對象，那這時候就需要引入原型模式是非常合適的

改造mail類

/**
* 實現cloneable接口
*/
public class Mail implements Cloneable{
    private String name;
    private String emailAddress;
    private String content;
    public Mail(){
        System.out.println("Mail class Constructor");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
	/**
	* 增加clone方法
	*/
    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("clone mail object");
        return super.clone();
    }
}

應用類

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Mail mail=new Mail();
        mail.setContent("初始化模板");

        for(int i=0;i<10;i++){
            Mail mailTemp= (Mail) mail.clone();
            mailTemp.setName("姓名"+i);
            mailTemp.setEmailAddress("姓名"+i+"@imooc.com");
            mailTemp.setContent("恭喜您，此次慕課網活動中獎了");
            MailUtil.sendMail(mailTemp);
        }
        MailUtil.saveOriginMailRecord(mail);
    }
}

運行結果

Mail class Constructor
clone mail object
向姓名0同學，郵件地址：姓名0@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名1同學，郵件地址：姓名1@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名2同學，郵件地址：姓名2@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名3同學，郵件地址：姓名3@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名4同學，郵件地址：姓名4@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名5同學，郵件地址：姓名5@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名6同學，郵件地址：姓名6@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名7同學，郵件地址：姓名7@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名8同學，郵件地址：姓名8@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
clone mail object
向姓名9同學，郵件地址：姓名9@imooc.com，郵件內容恭喜您，此次慕課網活動中獎了發送郵件成功
存儲originMail記錄，originMail:初始化模板

抽象類實現克隆接口原型模式

public class A implements Cloneable {

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class B extends A {
    public static void main(String[] args) throws CloneNotSupportedException {
        B b=new B();
        b.clone();

    }
}

這種方式也比較常見，如果我們的業務模型，可以抽象出來的話也可以使用這種方式，但是實際業務開發中使用上面一種還是較多，直接讓目標類來實現克隆接口

淺克隆和深克隆

原型模式雖然簡單，但是用不好的話，很容易產生bug

public class Pig implements Cloneable{
    private String name;
    private Date birthday;

    public Pig(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                '}'+super.toString();
    }
}

應用類

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date birthday=new Date(0L);
        Pig pig1=new Pig("佩奇",birthday);
        Pig pig2= (Pig) pig1.clone();
        System.out.println(pig1);
        System.out.println(pig2);

    }
}

運行結果

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.design.pattern.creational.prototype.clone.Pig@2c7b84de
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.design.pattern.creational.prototype.clone.Pig@3fee733d
修改pig1的生日後
Pig{name='佩奇', birthday=Wed Apr 04 19:51:06 CST 2181}com.design.pattern.creational.prototype.clone.Pig@2c7b84de
Pig{name='佩奇', birthday=Wed Apr 04 19:51:06 CST 2181}com.design.pattern.creational.prototype.clone.Pig@3fee733d

看到重新設置完pig1的生日後，Pig@2c7b84de生效了，但是pig2 Pig@3fee73d也變成了2181年，這個就很神奇了，這是默認情況Pig類實現的是淺克隆，那深克隆要怎麼做呢？只需要修改Pig類，在clone時候，把生日也給克隆了

@Override
protected Object clone() throws CloneNotSupportedException {
    Pig pig= (Pig) super.clone();
    //深克隆
    pig.birthday= (Date) pig.birthday.clone();
    return pig;
}

對於Pig裏面這種生日引用對象也得單獨進行克隆，所以我們在使用原型模式的時候，這個坑一定要注意，否則很容易引起bug的。
我們再運行一次

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.design.pattern.creational.prototype.clone.Pig@2c7b84de
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.design.pattern.creational.prototype.clone.Pig@3fee733d
修改pig1的生日後
Pig{name='佩奇', birthday=Wed Apr 04 19:51:06 CST 2181}com.design.pattern.creational.prototype.clone.Pig@2c7b84de
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.design.pattern.creational.prototype.clone.Pig@3fee733d

前面的2個就不看了，就看後面兩個，看到修改了pig1的生日後，pig2生日並沒有改變
這個非常重要，原型模式簡單但是有坑，所以我們在使用的時候，一定要注意深克隆和淺克隆，對於這種引用類型使用的時候一定要注意深克隆還是淺克隆它，對於引用類型使用時還是建議克隆它爲好，否則就是在爲項目埋坑

克隆破壞單例

原型模式有個小彩蛋，對於原型模式的理解，想象一下如果和單例模式結合起來應用的話會怎樣呢？
這個在面試的時候也有可能會被問到如何破壞單例模式，通過原型模式裏面的克隆也是方法

/**
 * 餓漢式
 */
public class HungrySingleton implements Serializable ,Cloneable{
    private final static HungrySingleton hungrySingleton=new HungrySingleton();
    private HungrySingleton(){
       if(hungrySingleton!=null){
           throw new RuntimeException("單例構造器禁止反射調用");
       }
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }

    /**
     * 增加該方法，返回這個單例對象
     * @return
     */
    private Object readResolve(){
        return hungrySingleton;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Test {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        HungrySingleton hungrySingleton=HungrySingleton.getInstance();
        Method method=hungrySingleton.getClass().getDeclaredMethod("clone");
        method.setAccessible(true);
        HungrySingleton cloneHungrySingleton= (HungrySingleton) method.invoke(hungrySingleton);
        System.out.println(hungrySingleton);
        System.out.println(cloneHungrySingleton);
    }
}

運行結果

com.design.pattern.creational.prototype.singleton.HungrySingleton@2626b418
com.design.pattern.creational.prototype.singleton.HungrySingleton@5a07e868

看到兩個對象不是一個，如何防止克隆對單例模式的破壞呢？這要怎麼辦呢？

可以讓HungrySingleton不去實現cloneable接口

修改clone方法

@Override
protected Object clone() throws CloneNotSupportedException {
    return getInstance();
}

運行結果

com.design.pattern.creational.prototype.singleton.HungrySingleton@2626b418
com.design.pattern.creational.prototype.singleton.HungrySingleton@2626b418

源碼解析

Object的clone方法

 protected native Object clone() throws CloneNotSupportedException;

實現cloneable接口的類

看到上圖都是實現了cloneable接口的類，我們看下mybatis裏的關於cache使用的Cachekey

    public CacheKey clone() throws CloneNotSupportedException {
        CacheKey clonedCacheKey = (CacheKey)super.clone();
        clonedCacheKey.updateList = new ArrayList(this.updateList);
        return clonedCacheKey;
    }

ArrayList實現了Cloneable接口並重寫了clone方法

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

看到實現了Cloneable接口，再看看clone方法是如何實現的

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

看到使用Arrays.copyOf方法，將裏面的元素copy了一份

HashMap實現了Cloneable接口並重寫了clone方法

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    @Override
    public Object clone() {
        HashMap<K,V> result;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
        result.reinitialize();
        result.putMapEntries(this, false);
        return result;
    }

對於原型模式，在使用過程中一定要注意，它是創建的對象和原來的對象是否是同一個，即它是創建出來的一個對象，還是隻是創建了一個引用，也就是要把深克隆和淺克隆要應用好

六、簡單又有坑的原型模式

文章目錄

定義

特點

類型

適用場景

優點

缺點

擴展

coding

目標類實現克隆接口原型模式

抽象類實現克隆接口原型模式

淺克隆和深克隆

克隆破壞單例

源碼解析

Object的clone方法

實現cloneable接口的類

ArrayList實現了Cloneable接口並重寫了clone方法

HashMap實現了Cloneable接口並重寫了clone方法

CORS error 但是 status code 是200 OK

壓縮上傳的GPU數據的方案

使用skopeo同步鏡像

十一、垃圾回收策略配置

Spring框架的本質：1Spring框架的起源

表的主鍵用數字還是UUID

事務機制主要是利用undo、redo日誌？

邏輯刪除還是物理刪除

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結