備忘錄模式 Memento 快照模式標記Token模式行為型設計模式（二十二）

備忘錄模式 Memento 又稱為快照模式標記Token模式是一種行為型設計模式，備忘錄模式在外部對對象的狀態進行保存，核心是如何外部保存並且數據還能夠保障安全隱私，本文對備忘錄模式的意圖、結構給出了簡單的介紹，並且給出了代碼的演化過程，以及備忘錄模式的Java實現以及變型，以及備忘錄模式的使用... ...

備忘錄模式 Memento

沿著腳印，走過你來時的路，回到原點。 苦海翻起愛恨在世間難逃避命運相親竟不可接近或我應該相信是緣份一首《一生所愛》觸動了多少人的心弦，一段五百年都沒有結果的愛情，讓多少人潸然淚下。有人說：當你真正看懂了《大話西游》，你就真的懂了愛情；那麼，當你聽懂了《一生所愛》，你就真的懂了什麼是哀傷和無奈。《大話西游》是不可超越的經典，在《月光寶盒》中，至尊寶為了救白晶晶，使用月光寶盒使時光倒流，幾次後產生故障，竟將其帶回五百年前，這時紫霞仙子（朱茵飾）向她走來...... 百度百科中關於詞條“VMware快照”的描述磁碟“快照”是虛擬機磁碟文件（VMDK）在某個點即時的複本。系統崩潰或系統異常，你可以通過使用恢復到快照來保持磁碟文件系統和系統存儲。當升級應用和伺服器及給它們打補丁的時候，快照是救世主。VMware快照是VMware Workstation里的一個特色功能。

“腳印”記錄了我們來時的路，所以我們可以原路返回； “月光寶盒”記錄了時間的狀態，所以至尊寶可以時光穿梭； “VMware快照”記錄了虛擬機磁碟文件（VMDK）在某個點的狀態，所以可以通過快照進行系統恢復； 以上，他們都記錄了狀態，進而可以恢復到原來的狀態

意圖

在不破壞封裝性的前提下，捕獲一個對象的內部狀態，併在該對象之外保存這個狀態。 這樣以後就可以將該對象恢復到原先保存的狀態。 別名：快照模式或者token標記模式 在程式開發過程中，有時可能需要記錄對象的狀態，以便允許用戶取消不確定的操作或者從錯誤恢復過來 對象的某個瞬時狀態，叫做快照（如同你去拍證件照，立等可取，快速的拍照，俗稱快照） 每一個快照，通常叫做一個檢查點。 想要實現快照和撤銷恢復機制，就必須將對象的狀態保存起來。 這就是備忘錄模式的初衷。面向對象的三大特征之一就是封裝，對象往往封裝了他的狀態信息，使之與外部的對象隔離這部分信息通常都是私有的private，不能被外部對象訪問，也就是說不能在外部進行保存如果暴露內部屬性比如設置為public，可以外部保存，但是這又違反了封裝的原則。換句話說，封裝起來，外部就不能直接訪問，但是我們又需要將他的狀態保存在外部而且還不想破壞封裝性，也不想暴露內部屬性。也就是如何將對象的狀態保存在外部，但是外部卻仍舊不知道對象的屬性細節？這個問題類似於：你想把你的一堆私人物品找個地方保存，但是你又不想別人看到你裡面的東西怎麼辦？最簡單的方式就是藉助於行李箱大家都坐過火車，在車站都有箱包寄存處我們把所有的物品鎖到行李箱中，行李箱寄存起來，管理員負責管理我們的行李箱，他並不知道我們箱子裡面裝的到底是什麼當我們回來取箱子時，管理員將箱子交還給我們，他自始至終都不知道箱子里是什麼在程式中，我們應該如何解決這個問題呢？也就是又能外部保存，又不破壞封裝？備忘錄模式就是解決這種場景問題的，通過引入備忘錄角色Memento和控制外界對他的訪問來解決。

結構

原發器角色Originator 也叫做發起者，原發器是需要被保存狀態的角色，也就是我們的業務邏輯對象他創建備忘錄Memento對象，也就是創建快照，並且負責藉助於備忘錄對象Memento恢復狀態 備忘錄角色Memento 負責記錄Originator的部分或者全部狀態，也就是擁有Originator的部分或者全部屬性備忘錄角色的設計必然要參考Originator 備忘錄角色應該僅僅允許Originator對其進行修改訪問，其他包括CareTaker只能夠對備忘錄進行傳遞備忘錄角色就是前文的“行李箱” 管理員角色CareTaker 負責管理保存備忘錄上面說到備忘錄模式的解決問題思路“引入備忘錄角色Memento和控制外界對他的訪問來解決” 具體為：

備忘錄模式通過引入備忘錄Memento記錄對象的內部狀態
引入管理員CareTaker對備忘錄進行管理
控制訪問--原發器Originator與備忘錄對象進行交互，其他所有地方都只是獲取傳遞，不更改設置Memento的狀態

也就是通過備忘錄對象對原始對象需要保存的內部狀態進行封裝 而且，控制對他的訪問，外人不能訪問內部這樣藉助於備忘錄對象這個中間層就實現了“在不破壞封裝性的前提下，捕獲一個對象的內部狀態，併在該對象之外保存這個狀態” 對於備忘錄對象訪問的控制是必須的，如果外界可以隨意訪問變更備忘錄對象某種程度上來說相當於可以更改原始對象的私有屬性了這是不安全的 備忘錄模式將“內部狀態”與“外界保存”進行解耦，通過中間層備忘錄對象來連接。

代碼示例

一個簡單的快照實現

有一個業務邏輯類Originator，快照主要是對他的狀態，也就是內部state屬性，進行備份
快照信息保存在備忘錄Memento中
通過管理員CareTaker進行保管

package memento.simple;
/**
* 業務邏輯類,也就是我們需要備份的對象
* 內部擁有state屬性,用來表示快照需要保存的狀態數據
*/
public class Originator {
    private Integer state;
    /**
    * 創建快照備份
    * @return
    */
    public Memento createMemento() {
        return new Memento(state);
    }
    /**
    * 恢復快照
    * @param memento
    */
    public void recovery(Memento memento) {
        state = memento.getState();
    }
     
    public Integer getState() {
        return state;
    }
     
    public void setState(Integer state) {
        this.state = state;
    }
     
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Originator{");
        sb.append("state=").append(state);
        sb.append('}');
        return sb.toString();
    }
}

package memento.simple;
/**
* 備忘錄類用來保存業務邏輯對象的狀態(原發器)
* 備忘錄類的屬性要參考原發器的設計,確定需要保存哪些數據信息
* 此處我們以state為演示
* 備忘錄類提供了getter和setter方法
*/
public class Memento {
    private Integer state;
    Memento(Integer state) {
        this.state = state;
    }
     
    public Integer getState() {
        return state;
    }
     
    public void setState(Integer state) {
        this.state = state;
    }
}

package memento.simple;
/**
* 管理員類,內部擁有一個memento,可以設置和獲取這個屬性
*/
public class CareTaker {
 
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
     
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

package memento.simple;
public class Test {
 
public static void main(String[] args) {
 
    //創建業務邏輯對象,設置狀態信息
    Originator originator = new Originator();
    originator.setState(2);
     
    //快照
    Memento memento = originator.createMemento();
    CareTaker careTaker = new CareTaker();
    careTaker.setMemento(memento);
     
    System.out.println("初始時狀態: " + originator.toString());
     
    originator.setState(3);
    System.out.println("更新狀態後: " + originator.toString());
     
    originator.setState(8);
    System.out.println("更新狀態後: " + originator.toString());
     
    originator.setState(6);
    System.out.println("更新狀態後: " + originator.toString());
     
    originator.recovery(careTaker.getMemento());
    System.out.println("恢復狀態後: " + originator.toString());
    }
}

上面的示例中，備忘錄Memento對象封裝保存原發器角色Originator的狀態，管理員CareTaker對備忘錄進行管理 Memento內部的屬性state，儘管我們設置了公有的訪問器 getter和setter，但是CareTaker以及外界並沒有對Memento進行訪問我們是藉助於代碼邏輯實現了：

Memento備忘錄對來自Originator的修改開放（比如上面的Originator可以創建Memento）
Memento備忘錄對來自CareTaker的修改開放（上面示例中，僅僅傳遞Memento，不曾訪問內部細節）

這種模式又被稱為白盒模式，因為Memento備忘錄大家都看得到，而且都能夠對她進行設置處理我們是藉助於“大家寫代碼的時候都不要訪問修改Memento備忘錄對象的屬性”這一要求完成的可能一不留神，某個人的代碼中就修改了Memento備忘錄對象。說白了，這種對原發器開放，對外界關閉的限制不是強制的，容易出問題。 怎麼才能夠強制將備忘錄類僅僅對原發器開放，對外界關閉？ 我們可以定義兩個介面，Open Close用於描述開放和關閉（close介面意為對外界封閉的介面）所有的對Memento的操作方法，全部定義在Open中，Close不定義任何方法，也就是標記介面給原發器Originator使用介面Open，外部所有的地方使用Close類型這樣所有使用Close的地方，都不能夠修改Memento對象

這樣在原來的基礎上，將限制增強了，只要是Close類型，那麼就不能修改Originator了不過顯然，Open介面也不是私有的，外界仍舊可以使用，所以只是比原來稍微強化一點並不能徹底解決

內部類方式重構

在java中，可以藉助內部類的形式因為內部類與外部類是友好的另外與Close介面結合使用，實現對外界的關閉 標記介面，外界看到的始終是標記介面，無方法可用

package memento;
public interface MementoInterface {
}

原發器，將Memento放置在內部，對外界僅僅返回標記介面只有內部才擁有真正的Memento類型

package memento;
/**
* 業務邏輯類,也就是我們需要備份的對象 內部擁有state屬性,用來表示快照需要保存的狀態數據
*/
public class Originator {
    private Integer state;
    /**
    * 創建快照備份返回標記介面,以使外界不能操作備忘錄
    */
    public Memento createMemento() {
        return new Memento(state);
    }
    /**
    * 恢復快照,接受MementoInterface類型參數 使用時強轉為內部類Memento
    */
    public void recovery(MementoInterface memento) {
        state = ((Memento) memento).getState();
    }
    public Integer getState() {
        return state;
    }
    public void setState(Integer state) {
        this.state = state;
    }
    /**
    * 私有內部類,實現MementoInterface介面,標記介面 用以外界交互,達到對外界close的效果
    */
    private class Memento implements MementoInterface {
            private Integer state;
         
        Memento(Integer state) {
            this.state = state;
        }
         
        public Integer getState() {
            return state;
        }
         
        public void setState(Integer state) {
            this.state = state;
        }
    }
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Originator{");
        sb.append("state=").append(state);
        sb.append('}');
        return sb.toString();
    }
}

外界僅僅接觸到MementoInterface類型 CareTaker維護memento

package memento;
/**
* 管理員類,內部擁有一個 MementoInterface,可以設置和獲取這個屬性
*/
public class CareTaker {
    private MementoInterface memento;
    public MementoInterface getMemento() {
        return memento;
    }
    public void setMemento(MementoInterface memento) {
        this.memento = memento;
    }
}

重構後的列印結果如上圖所示與原來一致，但是外界卻不能修改備忘錄對象，備忘錄僅僅對原發器開放

上圖為重構後的結構 Memento作為Originator的內部類，有外部類的引用隱藏了Open介面，或者說Memento自身也代表了Open介面角色，提供方法可以給外部類Originator使用 CareTaker通過MementoInterface交互，無法訪問Memento內部屬性客戶端訪問Originator和CareTaker，藉助於CareTaker管理CareTaker創建的快照

時序圖

時序圖上半部分（1,2,3）為快照保存，下半部分（4,5）為快照恢復步驟解析：

客戶端程式對原發器Originator進行狀態設置
客戶端程式對原發器進行快照創建
客戶端程式對快照進行保存
客戶端程式獲得快照
客戶端程式根據快照進行狀態恢復

重構小結

重構的邏輯為：

藉助於私有內部類實現了對外界的封閉
將負責人管理員CareTaker與Memento進行解耦，通過抽象MementoInterface進行連接

也就是使用MementoInterface作為外界與Memento訪問的中間層更加合理的實現了“在不破壞封裝性的前提下，捕獲一個對象的內部狀態，併在該對象之外保存這個狀態” 多版本快照 上面的示例中，CareTaker僅僅定義了一個內部屬性 private MementoInterface memento; 也就是只能保存一種狀態，實際情況下顯然不會如此簡單，所以可以藉助於集合框架對快照進行管理比如使用HashMap（String,MementoInterface）進行快照版本控制，key可以為版本號

形式變換

CareTaker管理功能的增強 在上面重構後的示例中，客戶端對Originator進行操作，並且負責快照的創建以及保存以及恢復快照時的快照讀取也就是說客戶端程式自身協調Originator與CareTaker，CareTaker僅僅負責快照的保存可以考慮將客戶端程式的功能封裝到CareTaker中 其餘部分不變，僅僅調整CareTaker 內部新增了屬性Originator，通過構造方法註入新增了創建快照和恢復的方法，底層依賴Originator 這就實現了客戶端功能的封裝

package memento.refactor1;
/**
* 管理員類,內部擁有一個 MementoInterface,可以設置和獲取這個屬性
*/
public class CareTaker {
 
    private MementoInterface memento;
    private Originator originator;
     
    CareTaker(Originator originator) {
    this.originator = originator;
    }
     
    /**
    * 創建快照,藉助於內部的Originator
    */
    public MementoInterface createMemento() {
        return originator.createMemento();
    }
     
    /**
    * 恢復快照,藉助於內部的Originator
    */
    public void recovery(MementoInterface memento) {
        originator.recovery(memento);
    }
    public MementoInterface getMemento() {
        return memento;
    }
    public void setMemento(MementoInterface memento) {
        this.memento = memento;
    }
}

變種形式實現了CareTaker對Originator的完全管理，而不僅僅是保存快照 簡化的CareTaker careTaker用於保存快照或者可以變形為大保姆，不僅僅保存快照，也用於Originator快照的創建與恢復在有些場景下，也可以省略CareTaker 在我們上面的示例測試主函數中，一邊創建了快照，很快下麵就用到了快照進行恢復這種場景，顯然沒有必要專門的安排管理員，可以省略CareTaker角色偽代碼:

public static void main(String[] args) {
Memento memento = originator.createMemento();
originator.recovery(originator.recovery();
}

Originator與Memento合併 備忘錄模式的根本在於狀態的保存，模式的結構是一種通用的解決方案 Memento對象是對於Originator內部部分或者全部狀態的一個封裝如果只是保存對象的狀態，也可以藉助於原型模式進行替代也就是說使用另外一個新的Originator對象保存當前Originator對象的狀態，這與白盒方式的備忘錄模式效果一樣

與命令模式的聯繫

命令模式中將“方法調用”這種命令行為或者說請求進一步的抽象封裝為一個命令對象，從而可以達到對請求記錄的功能，進而可以實現撤銷操作。備忘錄模式也是為了記錄對象的內部狀態，為實現撤銷操作做基礎工作。命令模式側重於請求歷史的日誌記錄，能夠記錄操作的軌跡，然後調用命令接收者的撤銷方法而撤銷方法基本上需要對象的內部狀態備忘錄模式則是記錄對象的狀態變化一個是巨集觀一個是微觀所以說，備忘錄模式與命令模式不是可替代關係，而是可以相互配合的好基友 命令模式記錄操作歷史，備忘錄模式記錄對象的狀態，一起配合實現撤銷的操作。

總結

備忘錄模式，模式如其名，就是記錄狀態信息。 備忘錄模式引入備忘錄角色將對象的“內部狀態”與“外部保存”進行解耦 通過對備忘錄角色的訪問限制，達到備忘錄對原發器Originator開放，對外界關閉的效果。備忘錄模式的重點在於對於Memento的訪問控制---對Originator開放，對外界關閉也就是通常所謂的雙介面支持，就是雙重標準嘛這也是一種設計思維，為了系統安全，提供一個標記介面給外部訪問。能夠保障系統的安全。通過對狀態的記錄，提供了狀態恢復的實現機制。每個備忘錄對象都是Originator對象的一個瞬時狀態，通過對狀態變化軌跡的記錄，可以實現多次狀態軌跡的還原。而且，複雜場景，還可以與命令模式結合使用。缺點也是明顯的，對於Originator對象的每一個瞬時狀態都使用Memento對象進行保存如果Originator對象本身很占用資源，那麼勢必導致占用過多的記憶體空間，這都是一個個的對象當你需要保存一個對象的瞬時的部分或者全部狀態時，可以考慮使用備忘錄模式原文地址:備忘錄模式 Memento 快照模式標記(Token)模式行為型設計模式（二十二）

備忘錄模式 Memento 快照模式 標記Token模式 行為型 設計模式（二十二）

意圖

結構