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

時間  2019-11-06
標籤 備忘錄 模式 memento 快照 標記 token 行爲 設計 二十二 简体版
原文   原文鏈接
備忘錄模式 Memento
image_5c19dcbd_5407
 
沿着腳印，走過你來時的路，回到原點。
 
 
苦海翻起愛恨
 
在世間難逃避命運
 
相親竟不可接近
 
或我應該相信是緣份
 
一首《一輩子所愛》觸動了多少人的心絃，一段五百年都沒有結果的愛情，讓多少人潸然淚下。
有人說：當你真正看懂了《大話西遊》，你就真的懂了愛情；那麼，當你聽懂了《一輩子所愛》，你就真的懂了什麼是哀傷和無奈。
《大話西遊》是不可超越的經典，在《月光寶盒》中，至尊寶爲了救白晶晶，使用月光寶盒使時光倒流，幾回後產生故障，竟將其帶回五百年前，這時紫霞仙子（朱茵飾）向她走來......
 
百度百科中關於詞條「VMware快照」的描述
磁盤「快照」是虛擬機磁盤文件（VMDK）在某個點即時的複本。
系統崩潰或系統異常，你能夠經過使用恢復到快照來保持磁盤文件系統和系統存儲。
當升級應用和服務器及給它們打補丁的時候，快照是救世主。VMware快照是VMware Workstation裏的一個特點功能。
 
image_5c19dcbd_6204
 
 
「腳印」記錄了咱們來時的路，因此咱們能夠原路返回；
「月光寶盒」記錄了時間的狀態，因此至尊寶能夠時光穿梭；
「VMware快照」記錄了虛擬機磁盤文件（VMDK）在某個點的狀態，因此能夠經過快照進行系統恢復；
以上，他們都記錄了狀態，進而能夠恢復到原來的狀態

意圖

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

結構

image_5c19dcbe_478c
原發器角色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());
    }
}

 

 
image_5c19dcbe_7c07
 
上面的示例中，備忘錄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對象
image_5c19dcbe_67cc
這樣在原來的基礎上，將限制加強了，只要是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;
    }
}
image_5c19dcbe_1f8c
重構後的打印結果如上圖所示與原來一致，可是外界卻不能修改備忘錄對象，備忘錄僅僅對原發器開放
 
image_5c19dcbe_310
上圖爲重構後的結構
Memento做爲Originator的內部類，有外部類的引用
隱藏了Open接口，或者說Memento自身也表明了Open接口角色，提供方法能夠給外部類Originator使用
CareTaker經過MementoInterface交互，沒法訪問Memento內部屬性
客戶端訪問Originator和CareTaker，藉助於CareTaker管理CareTaker建立的快照

時序圖

image_5c19dcbe_465
時序圖上半部分（1,2,3）爲快照保存，下半部分（4,5）爲快照恢復
步驟解析：
  1. 客戶端程序對原發器Originator進行狀態設置
  2. 客戶端程序對原發器進行快照建立
  3. 客戶端程序對快照進行保存
  4. 客戶端程序得到快照
  5. 客戶端程序根據快照進行狀態恢復

重構小結

重構的邏輯爲：
  • 藉助於私有內部類實現了對外界的封閉
  • 將負責人管理員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對象自己很佔用資源，那麼勢必致使佔用過多的內存空間，這都是一個個的對象
 
當你須要保存一個對象的瞬時的部分或者所有狀態時，能夠考慮使用備忘錄模式
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程