備忘錄模式——Memento
案例展示——Memento怎麼用？
在電影中，月光寶盒是一種可以穿越時空的寶物，持有月關寶盒的人可以去到任意的時間，也可以迅速的回到原來的時間。當然，在現實中，起碼在現在的科技水平下，人類的科技是無法做到時空穿梭的程度的，但是作為程式設計師，我們卻可以通過程式設計來體驗這種任意穿梭時間的樂趣，下面是設計類圖：
類圖元素分析如下：
-
TimeMachine：這就是前面說的月關寶盒類了，這個類會顯示當前月關寶盒所在的年代，同時可以建立一個備份儲存這個年代，以便以後可以返回
-
Memento：備忘錄類，這是一個Javabean，就是單純的為TimeMachine儲存一個年代資訊
-
Caretaker：備忘錄的管理類，通過這個類去管理備忘錄類，高層模組不必要直接和備忘錄接觸，降低耦合
下面是程式碼實現：
// 時間機器——月關寶盒
public class TimeMachine {
// 年代
private String time = "";
// 改變年代
public void changeTime() {
this.time = "公元1970-1-1 00:00:00，我是月光寶盒，今天是我的生日！";
}
public void setTime(String time) {
this.time = time;
}
public String getTime() {
return 看見結果是不是很神奇，我們可以任意的穿梭時空啦，想到哪裡就去哪裡，但是最重要的就是在去之前要備份一下，以免到時候回不來。在這個設計中我們就用到了備忘錄模式。
深入分析——Memento是什麼？
Memento的定義
定義： 在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態，這樣就可以將該物件恢復到原先儲存的狀態。下面其通用類圖：
類圖元素分析：
-
Originator發起人角色：記錄當前時刻的內部狀態，負責定義哪些屬於備份範圍的狀態，負責建立和恢復備忘錄資料
-
Memento備忘錄角色：負責儲存Originator發起人物件的內部狀態，在需要的時候提供發起人需要的內部狀態
-
Caretaker備忘錄管理員角色：對備忘錄進行管理、儲存和提供備忘錄
Memento的幾種擴充套件形式
1. clone方式的備忘錄
通過複製的方式產生一個內部物件，這是一種簡單好用的方法，其類圖如下：
程式碼實現如下：
// 發起人自主備份和恢復
public class Originator implements Cloneable {
// 當前發起人的備份
private Originator backup;
// 內部狀態
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
// 建立一個備忘錄
public void createMemento() {
this.backup = (Originator) this.clone();
}
// 恢復一個備忘錄
public void restoreMemento() {
// 斷言備忘錄不為空
Assert.assertNotNull(backup);
this.setState(this.backup.getState());
}
// 克隆當前物件
@Override
protected Object clone(){
try {
return (Originator) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
// 在一個場景中執行
public class Client {
public static void main(String[] args) {
// 定義發起人
Originator originator = new Originator();
// 建立初始狀態
originator.setState("初始狀態....");
System.out.println("初始狀態是：" + originator.getState());
// 建立備份
originator.createMemento();
// 修改狀態
originator.setState("修改後的狀態...");
System.out.println("修改後的狀態是：" + originator.getState());
// 恢復原有狀態
originator.restoreMemento();
System.out.println("恢復後的狀態是：" + originator.getState());
}
}
結果如下：
初始狀態是：初始狀態....
修改後的狀態是：修改後的狀態...
恢復後的狀態是：初始狀態....
我們發現結果沒有變化，完美的實現了我們的需求，同時程式更加精簡。但是由於深拷貝和淺拷貝存在的問題，在複雜場景下會讓程式的邏輯變得很複雜，所以基於克隆的備忘錄模式適用於較為簡單的場景，不要與其他的物件產生嚴重的耦合關係。
2. 多狀態的備忘錄模式
在前面介紹的案例中，發起人角色Originator只有一個狀態，我們只需要備份一個狀態就可以，那要是在複雜場景中出現了多個狀態值需要備份怎麼辦呢？這時我們可以使用前面的介紹的通過克隆的備忘錄模式，也可以使用下面介紹的方法。類圖設計如下：
分析：將多個狀態值按照鍵值對(屬性-屬性值)的形式存放在HashMap中，通過一個工具類BeanUtils來獲取屬性值或者設定屬性值
下面是程式碼實現：
// 發起人角色：有多個狀態
public class Originator {
// 內部狀態
private String state1 = "";
private String state2 = "";
private String state3 = "";
public String getState1() {
return state1;
}
public void setState1(String state1) {
this.state1 = state1;
}
public String getState2() {
return state2;
}
public void setState2(String state2) {
this.state2 = state2;
}
public String getState3() {
return state3;
}
public void setState3(String state3) {
this.state3 = state3;
}
// 建立一個備忘錄
public Memento createMemento() {
return new Memento(BeanUtils.backupProp(this));
}
// 恢復一個備忘錄
public void restoreMemento(Memento memento) {
BeanUtils.restoreProp(this, memento.getStateMap());
}
@Override
public String toString() {
return "Originator{" +
"state1='" + state1 + '\'' +
", state2='" + state2 + '\'' +
", state3='" + state3 + '\'' +
'}';
}
}
// 備忘錄類
public class Memento {
// 狀態值存放在一個HashMap中
private HashMap<String, Object> stateMap;
// 接收一個物件，建立一個備份
public Memento(HashMap<String, Object> map) {
this.stateMap = map;
}
public HashMap<String, Object> getStateMap() {
return stateMap;
}
public void setStateMap(HashMap<String, Object> stateMap) {
this.stateMap = stateMap;
}
}
// 備忘錄管理員類
public class Caretaker {
// 備忘錄物件
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
// 工具類
public class BeanUtils {
// 把bean的所有屬性和數值放到HashMap中：使用反射獲取
public static HashMap<String, Object> backupProp(Object bean) {
HashMap<String, Object> result = new HashMap<String, Object>(16);
try {
// 獲得bean的描述
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
// 獲得屬性描述
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
// 遍歷所有的屬性
for (PropertyDescriptor des:descriptors) {
// 屬性名稱
String fieldName = des.getName();
// 讀取屬性的方法
Method getter = des.getReadMethod();
// 讀取屬性值
Object fieldValue = getter.invoke(bean, new Object[]{});
if (!fieldName.equalsIgnoreCase("class")) {
result.put(fieldName, fieldValue);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
// 把HashMap的值返回到bean中
public static void restoreProp(Object bean, HashMap<String, Object> propMap) {
try {
// 獲得bean的描述
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
// 獲得屬性描述
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
// 遍歷所有的屬性
for (PropertyDescriptor des:descriptors) {
// 屬性名稱
String fieldName = des.getName();
// 如果有這個屬性，設定值
if (propMap.containsKey(fieldName)) {
// 寫屬性的方法
Method setter = des.getWriteMethod();
setter.invoke(bean, new Object[]{propMap.get(fieldName)});
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
//在一個場景中測試
public class Client {
public static void main(String[] args) {
// 定義一個發起人
Originator ori = new Originator();
// 定義出備忘錄管理員
Caretaker caretaker = new Caretaker();
// 初始化
ori.setState1("籃球");
ori.setState2("足球");
ori.setState3("乒乓球");
System.out.println("=======初始化狀態=====\n" + ori);
// 建立一個備忘錄
caretaker.setMemento(ori.createMemento());
// 修改狀態值
ori.setState1("蔬菜");
ori.setState2("水果");
ori.setState3("海鮮");
System.out.println("\n=======修改後狀態======\n" + ori);
// 恢復備忘錄中儲存的狀態
ori.restoreMemento(caretaker.getMemento());
System.out.println("\n=======恢復後狀態======\n" + ori);
}
}
結果如下：
=======初始化狀態=====
Originator{state1='籃球', state2='足球', state3='乒乓球'}
=======修改後狀態======
Originator{state1='蔬菜', state2='水果', state3='海鮮'}
=======恢復後狀態======
Originator{state1='籃球', state2='足球', state3='乒乓球'}
3. 多備份的備忘錄
備忘錄也可以有多個，我們可以建立多個備份，然後選擇回到哪個備份。其實這樣的場景會有很多，比如視訊監控，我們想回到某某時間段，那這個備份的必須是連續的，每一個時間點就是一個備份點，通過這個備份點我們就能回到那個狀態，下面是程式碼實現(只給出修改部分)：
// 備忘錄管理員：通過HashMap來存放多個備忘錄——(備份點索引, 備忘錄物件)
public class Caretaker {
// 使用HashMap來存放多個備忘錄
private HashMap<String, Memento> memMap = new HashMap<String, Memento>(16);
public Memento getMemento(String index) {
return memMap.get(index);
}
public void setMemento(String index, Memento memento) {
this.memMap.put(index, memento);
}
}
// 客戶端
public class Client {
public static void main(String[] args) {
// 定義發起人
Originator originator = new Originator();
// 定義出備忘錄管理員
Caretaker caretaker = new Caretaker();
// 建立多個備忘錄
caretaker.setMemento("001", originator.createMemento());
caretaker.setMemento("002", originator.createMemento());
// 恢復指定標記的備忘錄
originator.restoreMemento(caretaker.getMemento("001"));
}
}
4. 更加安全的備忘錄
備忘錄的資料一般來說是不允許修改的，這就要求我們將其保護的更好，縱觀我們前面的設計，備忘錄暴露在外，任何人都可以對其進行修改。這樣設計是很不安全的，所以可以將備忘錄的閱讀許可權縮小，比如作為發起人的一個私有內部類，外部的話就宣告一個沒有任何方法的備忘錄介面，其他一切對備忘錄的訪問都通過這個介面進行，只允許使用，不允許修改，這樣就會安全的多(當然無法防止通過反射去修改)，下面是類圖設計：
下面是程式碼實現：
// 備忘錄介面
public interface IMemento {
}
// 發起人角色
public class Originator {
// 狀態
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
// 建立一個備忘錄
public Memento createMemento() {
return new Memento(this.state);
}
// 恢復一個備忘錄
public void restoreMemento(Memento memento) {
this.setState(memento.getState());
}
// 內部類
private class Memento implements IMemento {
// 發起人的內部狀態
private String state = "";
// 建構函式進行引數傳遞
public Memento(String state) {
this.state = state
相關推薦
七、備忘錄模式Memento（行為型模式）
版本號 center 方式 some 接口 ica 是否有效 eve 提醒
其目的是,在不違反封裝原則的前提下.採集和備份一個對象的內部狀態以便這個對象能夠在以後恢
行為型_備忘錄模式(Memento)
nat count() .com take 增加 clas ostream 分享圖片 行為型 行為型_備忘錄模式(Memento)
作用場景：
當意圖在對象外面保存對象的內部狀態，但是又不想破壞對象的封裝性，就可以考慮備忘錄模式。
解釋：
其參與者包括
1、Memnto(備
備忘錄模式——Memento
案例展示——Memento怎麼用？
在電影中，月光寶盒是一種可以穿越時空的寶物，持有月關寶盒的人可以去到任意的時間，也可以迅速的回到原來的時間。當然，在現實中，起碼在現在的科技水平下，人類的科技是無法做到時空穿梭的程度的，但是作為程式設計師，我們卻可以通過程
面向物件設計模式之---備忘錄模式(Memento Pattern)
今天要向大家介紹的模式是備忘錄模式，有時又稱作快照模式。
這個備忘錄模式一個典型的應用場景就是遊戲存檔。有時候為了打Boss，沒有成功，反而被Boss打死了，這個時候就需要利用我們之前的存檔回到最接近Boss的那一關再繼續。
備忘錄模式的定義如下：
在不破壞封裝性的前
設計模式------備忘錄模式(Memento pattern)
一、引子 俗話說：世上難買後悔藥。所以凡事講究個“三思而後行”，但總常見有人做“痛心疾首”狀：當初我要是……。如果真的有《大話西遊》中能時光倒流的“月光寶盒”，那這世上也許會少一些傷感與後悔——當然這隻能是痴人說夢了。
但是在我們手指下的程式世界裡，卻有的後悔藥買。今天我們要講的備忘錄模式便是程式世
備忘錄模式（Memento）
ring 信息 out 根據 string 歷史 role 還原 html 備忘錄模式：在不破壞封裝性的前提下，捕捉一個對象的內部狀態，並在改對象之外保存這個狀態。這樣以後就可將該對象恢復到原先保存的狀態。
備忘錄模式比較適合功能比較復雜的，但需要維護或記錄屬性歷史的類。或
設計模式的征途—20.備忘錄（Memento）模式
行為 修煉之道 mda 3.2 ima 位置 pri 捕獲 spl 相信每個人都有後悔的時候，但是人生並無後悔藥，有些錯誤一旦發生就無法再挽回，有些事一旦錯過就不會再重來，有些話一旦說出口也就不可能再收回，這就是人生。為了不讓自己後悔，我們總是需要三思而後行。這裏我們要學習
C#設計模式(23)——備忘錄模式（Memento Pattern）
block con 通訊 想是 multiple 數字 優缺點 引用 get 原文:C#設計模式(23)——備忘錄模式（Memento Pattern）一、引言
在上一篇博文分享了訪問者模式，訪問者模式的實現是把作用於某種數據結構上的操作封裝到訪問者中，使得操作和數
C#設計模式之二十二備忘錄模式（Memento Pattern）【行為型】
his 備忘錄 很好 car 人的 成功率 構圖 設計模式的 就會 原文:C#設計模式之二十二備忘錄模式（Memento Pattern）【行為型】一、引言 今天我們開始講“行為型”設計模式的第十個模式，該模式是【備忘錄模式】，英文名稱是：Memento Pattern
備忘錄模式（Memento Pattern）。
定義
備忘錄模式提供了一種彌補真實世界缺陷的方法，讓“後悔藥”在程式的世界中真實可行，其定義如下：
在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態。這樣以後就可將該物件恢復到原先儲存的狀態。
通俗的說，備忘錄模式就是一個物件的備份模式，提供了
重走Java設計模式——備忘錄模式（Memento Pattern）
備忘錄模式
定義
在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態。
模式結構
發起者角色(Originator)：負責建立一個備忘錄用以記錄當前時刻它的內部狀態，並可以
我所理解的設計模式（C++實現）——備忘錄模式（Memento Pattern）
概述：
我們玩單機遊戲的時候總會遇到老婆大人的各位事情，一會去買瓶醋了，一會去打個醬油了，會耽誤我們玩遊戲的程序，但是此時我們能有“儲存遊戲”這個寶貝，我們的主基地不會在我們打醬油的時候被對手拆掉。
這“儲存遊戲”的功能其實就是備忘錄模式的很好應用，她是在不
研磨設計模式 之 備忘錄模式（Memento）1——跟著cc學設計系列
19.1 場景問題
19.1.1 開發模擬系統
考慮這樣一個模擬應用，功能是：模擬運行鍼對某個具體問題的多個解決方案，記錄執行過程的各種資料，在模擬執行完成過後，好對這多個解決方案進行比較和評價，從而選定最優的解決方案。
這種模擬系統，在很多領域都有應用，比如：工作流系
淺談JAVA設計模式之——備忘錄模式（Memento）
一、概述
在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態。這樣以後就可將該物件恢復到原先儲存的狀態。
二、適用性
1.必須儲存一個物件在某一個時刻的(部分)狀態,這樣以後需要時它才能恢復到先前的狀態。
2.如果一個用介面來讓其它物件直接得到這
18.備忘錄模式（Memento Pattern）
引子
俗話說：世上難買後悔藥。所以凡事講究個“三思而後行”，但總常見有人做“痛心疾首”狀：當初我要是……。如果真的有《大話西遊》中能時光倒流的“月光寶盒”，那這世上也許會少一些傷感與後悔——當然這隻能是痴人說夢了。
但是在我們手指下的程式世界裡，卻有的後悔藥買。今天我們要講的
（行為模式）MEMENTO——備忘錄模式
1、意圖
在不破壞封裝的條件下，將一個物件的狀態捉住，並在該物件外部儲存這個狀態，從而可以在將來合適的時候把這個物件還原到儲存起來的狀態。
2、核心思想
備忘錄物件是一個用來儲存另外一個物件內部狀態的快照的物件。
3、優缺點分析
適用於功能比較複雜的，
C++設計模式-Memento備忘錄模式
Memento模式作用：在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態，這樣以後就可將該物件恢復到原先儲存的狀態。
UML圖：
Originator：負責建立一個備忘錄Memento，用以記錄當前時刻它的內部狀態，並可使用備忘錄恢復內部狀
設計模式-備忘錄模式實現悔棋操作
exc turn color new label isp lis args set 利用設計模式中的備忘錄模式實現多步悔棋的操作
1 import java.util.*;
2 class Chessman {
3 private String lab
面向對象編程思想-備忘錄模式
使用 存儲 exc 進度 通過 今天 time program tor 一、引言
上篇博文中我們分享了訪問者模式，訪問者模式是把作用於數據結構上的操作封裝到訪問者類中，使得數據結構與操作分離。今天我們要學習的備忘錄模式與命令模式有點相似，不同的是，命令模式保存的是發起人的具
設計模式之備忘錄模式
set 2017年 image 對象 array mem .com void oid
代碼實現
/**
* 源發器類
* @author bzhx
* 2017年3月15日
*/
public class Emp {
private