定義：在不破壞封裝性的前提下，捕獲一個對象的內部狀態，并在該對象之外保存這個狀態。這樣就可以將該對象恢復到原先保存的狀態。
類型：行為類
類圖：
我們在編程的時候，經常需要保存對象的中間狀態，當需要的時候，可以恢復到這個狀態。比如，我們使用eclipse進行編程時，假如編寫失誤（例如不小心誤刪除了幾行代碼），我們希望返回刪除前的狀態，便可以使用ctrl+z來進行返回。這時我們便可以使用備忘錄模式來實現。
備忘錄模式的結構
發起人：記錄當前時刻的內部狀態，負責定義哪些屬于備份范圍的狀態，負責創建和恢復備忘錄數據。
備忘錄：負責存儲發起人對象的內部狀態，在需要的時候提供發起人需要的內部狀態。
管理角色：對備忘錄進行管理，保存和提供備忘錄。
通用代碼實現
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
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()); } } class memento { private string state = ""; public memento(string state){ this.state = state; } public string getstate() { return state; } public void setstate(string state) { this.state = state; } } class caretaker { private memento memento; public memento getmemento(){ return memento; } public void setmemento(memento memento){ this.memento = memento; } } public class client { public static void main(string[] args){ originator originator = new originator(); originator.setstate("狀態1"); system.out.println("初始狀態:"+originator.getstate()); caretaker caretaker = new caretaker(); caretaker.setmemento(originator.creatememento()); originator.setstate("狀態2"); system.out.println("改變后狀態:"+originator.getstate()); originator.restorememento(caretaker.getmemento()); system.out.println("恢復后狀態:"+originator.getstate()); } } |
代碼演示了一個單狀態單備份的例子，邏輯非常簡單：originator類中的state變量需要備份，以便在需要的時候恢復；memento類中，也有一個state變量，用來存儲originator類中state變量的臨時狀態；而caretaker類就是用來管理備忘錄類的，用來向備忘錄對象中寫入狀態或者取回狀態。
多狀態多備份備忘錄
通用代碼演示的例子中，originator類只有一個state變量需要備份，而通常情況下，發起人角色通常是一個javabean，對象中需要備份的變量不止一個，需要備份的狀態也不止一個，這就是多狀態多備份備忘錄。
實現備忘錄的方法很多，備忘錄模式有很多變形和處理方式，像通用代碼那樣的方式一般不會用到，多數情況下的備忘錄模式，是多狀態多備份的。其實實現多狀態多備份也很簡單，最常用的方法是，我們在memento中增加一個map容器來存儲所有的狀態，在caretaker類中同樣使用一個map容器才存儲所有的備份。下面我們給出一個多狀態多備份的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
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()); } public string tostring(){ return "state1="+state1+"state2="+state2+"state3="+state3; } } class memento { private map<string, object> statemap; public memento(map<string, object> map){ this.statemap = map; } public map<string, object> getstatemap() { return statemap; } public void setstatemap(map<string, object> statemap) { this.statemap = statemap; } } class beanutils { public static map<string, object> backupprop(object bean){ map<string, object> result = new hashmap<string, object>(); try{ 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; } public static void restoreprop(object bean, map<string, object> propmap){ try { 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(); } } } class caretaker { private map<string, memento> memmap = new hashmap<string, memento>(); public memento getmemento(string index){ return memmap.get(index); } public void setmemento(string index, memento memento){ this.memmap.put(index, memento); } } 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("001",ori.creatememento()); ori.setstate1("軟件"); ori.setstate2("架構"); ori.setstate3("優秀"); system.out.println("===修改后狀態===\n"+ori); ori.restorememento(caretaker.getmemento("001")); system.out.println("===恢復后狀態===\n"+ori); } } |
備忘錄模式的優缺點和適用場景
備忘錄模式的優點有：
當發起人角色中的狀態改變時，有可能這是個錯誤的改變，我們使用備忘錄模式就可以把這個錯誤的改變還原。
備份的狀態是保存在發起人角色之外的，這樣，發起人角色就不需要對各個備份的狀態進行管理。
備忘錄模式的缺點有：
在實際應用中，備忘錄模式都是多狀態和多備份的，發起人角色的狀態需要存儲到備忘錄對象中，對資源的消耗是比較嚴重的。
如果有需要提供回滾操作的需求，使用備忘錄模式非常適合，比如jdbc的事務操作，文本編輯器的ctrl+z恢復等。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
