备忘录模式又叫做快照模式(Snapshot Pattern)或Token模式，是对象的行为模式。

　　备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代子模式一同使用。

备忘录模式的结构

　　备忘录模式的结构图如下所示

　　备忘录模式所涉及的角色有三个：备忘录(Memento)角色、发起人(Originator)角色、负责人(Caretaker)角色。

　　备忘录(Memento)角色

　　备忘录角色又如下责任：

　　（1）将发起人（Originator）对象的内战状态存储起来。备忘录可以根据发起人对象的判断来决定存储多少发起人（Originator）对象的内部状态。

　　（2）备忘录可以保护其内容不被发起人（Originator）对象之外的任何对象所读取。

　　备忘录有两个等效的接口：

　　●　　窄接口：负责人（Caretaker）对象（和其他除发起人对象之外的任何对象）看到的是备忘录的窄接口(narrow interface)，这个窄接口只允许它把备忘录对象传给其他的对象。

　　●　　宽接口：与负责人对象看到的窄接口相反的是，发起人对象可以看到一个宽接口(wide interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。

　　发起人（Originator）角色

　　发起人角色有如下责任：

　　（1）创建一个含有当前的内部状态的备忘录对象。

　　（2）使用备忘录对象存储其内部状态。

　　负责人（Caretaker）角色

　　负责人角色有如下责任：

　　（1）负责保存备忘录对象。

　　（2）不检查备忘录对象的内容。

　“白箱”备忘录模式的实现

　　备忘录角色对任何对象都提供一个接口，即宽接口，备忘录角色的内部所存储的状态就对所有对象公开。因此这个实现又叫做“白箱实现”。

　　“白箱”实现将发起人角色的状态存储在一个大家都看得到的地方，因此是破坏封装性的。但是通过程序员自律，同样可以在一定程度上实现模式的大部分用意。因此白箱实现仍然是有意义的。

　　下面给出一个示意性的“白箱实现”。

　　源代码

　　发起人角色类，发起人角色利用一个新创建的备忘录对象将自己的内部状态存储起来。

[java] view
plaincopyprint?

1. package com.bankht.Memento;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:12:20
5. *
6. * @类说明 ：发起人角色类，发起人角色利用一个新创建的备忘录对象将自己的内部状态存储起来。
7. */
8. public class Originator {
9. private String state;
10. /**
11. * 工厂方法，返回一个新的备忘录对象
12. */
13. public Memento createMemento() {
14. return new Memento(state);
15. }
16. /**
17. * 将发起人恢复到备忘录对象所记载的状态
18. */
19. public void restoreMemento(Memento memento) {
20. this.state = memento.getState();
21. }
22. public String getState() {
23. return state;
24. }
25. public void setState(String state) {
26. this.state = state;
27. System.out.println("当前状态：" + this.state);
28. }
29. }

　　备忘录角色类，备忘录对象将发起人对象传入的状态存储起来。

[java] view
plaincopyprint?

1. package com.bankht.Memento;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:12:40
5. *
6. * @类说明 ：备忘录角色类，备忘录对象将发起人对象传入的状态存储起来。
7. */
8. public class Memento {
9. private String state;
10. public Memento(String state) {
11. this.state = state;
12. }
13. public String getState() {
14. return state;
15. }
16. public void setState(String state) {
17. this.state = state;
18. }
19. }

　　负责人角色类，负责人角色负责保存备忘录对象，但是从不修改（甚至不查看）备忘录对象的内容。

[java] view
plaincopyprint?

1. package com.bankht.Memento;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:13:03
5. *
6. * @类说明 ：负责人角色类，负责人角色负责保存备忘录对象，但是从不修改（甚至不查看）备忘录对象的内容。
7. */
8. public class Caretaker {
9. private Memento memento;
10. /**
11. * 备忘录的取值方法
12. */
13. public Memento retrieveMemento() {
14. return this.memento;
15. }
16. /**
17. * 备忘录的赋值方法
18. */
19. public void saveMemento(Memento memento) {
20. this.memento = memento;
21. }
22. }

　　客户端角色类

[java] view
plaincopyprint?

1. package com.bankht.Memento;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:13:24
5. *
6. * @类说明 ：客户端角色类
7. */
8. public class Client {
9. public static void main(String[] args) {
10. Originator o = new Originator();
11. Caretaker c = new Caretaker();
12. // 改变负责人对象的状态
13. o.setState("On");
14. // 创建备忘录对象，并将发起人对象的状态储存起来
15. c.saveMemento(o.createMemento());
16. // 修改发起人的状态
17. o.setState("Off");
18. // 恢复发起人对象的状态
19. o.restoreMemento(c.retrieveMemento());
20. System.out.println(o.getState());
21. }
22. }

　　在上面的这个示意性的客户端角色里面，首先将发起人对象的状态设置成“On”，并创建一个备忘录对象将这个状态存储起来；然后将发起人对象的状态改成“Off”；最后又将发起人对象恢复到备忘录对象所存储起来的状态，即“On”状态。

　　系统的时序图更能够反映出系统各个角色被调用的时间顺序。如下图是将发起人对象的状态存储到白箱备忘录对象中去的时序图。

　　可以看出系统运行的时序是这样的：

　　（1）将发起人对象的状态设置成“On”。

　　（2）调用发起人角色的createMemento()方法，创建一个备忘录对象将这个状态存储起来。

　　（3）将备忘录对象存储到负责人对象中去。

　　将发起人对象恢复到备忘录对象所记录的状态的时序图如下所示：

　　可以看出，将发起人对象恢复到备忘录对象所记录的状态时，系统的运行时序是这样的：

　　（1）将发起人状态设置成“Off”。

　　（2）将备忘录对象从负责人对象中取出。

　　（3）将发起人对象恢复到备忘录对象所存储起来的状态，即“On”状态。

　“黑箱”备忘录模式的实现

　　备忘录角色对发起人（Originator）角色对象提供一个宽接口，而为其他对象提供一个窄接口。这样的实现叫做“黑箱实现”。

　　在JAVA语言中，实现双重接口的办法就是将备忘录角色类设计成发起人角色类的内部成员类。

　　将Memento设成Originator类的内部类，从而将Memento对象封装在Originator里面；在外部提供一个标识接口MementoIF给Caretaker以及其他对象。这样，Originator类看到的是Menmento的所有接口，而Caretaker以及其他对象看到的仅仅是标识接口MementoIF所暴露出来的接口。

　　使用内部类实现备忘录模式的类图如下所示。

　　源代码

　　发起人角色类Originator中定义了一个内部的Memento类。由于此Memento类的全部接口都是私有的，因此只有它自己和发起人类可以调用。

[java] view
plaincopyprint?

1. package com.bankht.Memento.sample2;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:33:55
5. *
6. * @类说明
7. *      ：发起人角色类Originator中定义了一个内部的Memento类。
8. *        由于此Memento类的全部接口都是私有的，因此只有它自己和发起人类可以调用。
9. */
10. public class Originator {
11. private String state;
12. public String getState() {
13. return state;
14. }
15. public void setState(String state) {
16. this.state = state;
17. System.out.println("赋值状态：" + state);
18. }
19. /**
20. * 工厂方法，返还一个新的备忘录对象
21. */
22. public MementoIF createMemento() {
23. return new Memento(state);
24. }
25. /**
26. * 发起人恢复到备忘录对象记录的状态
27. */
28. public void restoreMemento(MementoIF memento) {
29. this.setState(((Memento) memento).getState());
30. }
31. private class Memento implements MementoIF {
32. private String state;
33. /**
34. * 构造方法
35. */
36. private Memento(String state) {
37. this.state = state;
38. }
39. private String getState() {
40. return state;
41. }
42. private void setState(String state) {
43. this.state = state;
44. }
45. }
46. }

　　窄接口MementoIF，这是一个标识接口，因此它没有定义出任何的方法。

[java] view
plaincopyprint?

1. package com.bankht.Memento.sample2;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:34:25
5. *
6. * @类说明 ：窄接口MementoIF，这是一个标识接口，因此它没有定义出任何的方法。
7. */
8. public interface MementoIF {
9. }

　　负责人角色类Caretaker能够得到的备忘录对象是以MementoIF为接口的，由于这个接口仅仅是一个标识接口，因此负责人角色不可能改变这个备忘录对象的内容。

[java] view
plaincopyprint?

1. package com.bankht.Memento.sample2;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:35:20
5. *
6. * @类说明 ：
7. *          负责人角色类Caretaker能够得到的备忘录对象是以MementoIF为接口的，由于这个接口仅仅是一个标识接口，
8. *          因此负责人角色不可能改变这个备忘录对象的内容。
9. */
10. public class Caretaker {
11. private MementoIF memento;
12. /**
13. * 备忘录取值方法
14. */
15. public MementoIF retrieveMemento() {
16. return memento;
17. }
18. /**
19. * 备忘录赋值方法
20. */
21. public void saveMemento(MementoIF memento) {
22. this.memento = memento;
23. }
24. }

　　客户端角色类

[java] view
plaincopyprint?

1. package com.bankht.Memento.sample2;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:36:01
5. *
6. * @类说明 ：客户端角色类
7. */
8. public class Client {
9. public static void main(String[] args) {
10. Originator o = new Originator();
11. Caretaker c = new Caretaker();
12. // 改变负责人对象的状态
13. o.setState("On");
14. // 创建备忘录对象，并将发起人对象的状态存储起来
15. c.saveMemento(o.createMemento());
16. // 修改发起人对象的状态
17. o.setState("Off");
18. // 恢复发起人对象的状态
19. o.restoreMemento(c.retrieveMemento());
20. }
21. }

　　客户端首先

　　（1）将发起人对象的状态设置为“On”。

　　（2）调用createMemento()方法，创建一个备忘录对象将这个状态存储起来（此时createMemento()方法还回的明显类型是MementoIF接口，真实类型为Originator内部的Memento对象）。

　　（3）将备忘录对象存储到负责人对象中去。由于负责人对象拿到的仅是MementoIF接口，因此无法读出备忘录对象内部的状态。

　　（4）将发起人对象的状态设置为“Off”。

　　（5）调用负责人对象的retrieveMemento()方法将备忘录对象取出。注意此时仅能得到MementoIF接口，因此无法读出此对象的内部状态。

　　（6）调用发起人对象的restoreMemento()方法将发起人对象的状态恢复成备忘录对象所存储的起来的状态，即“On”状态。由于发起人对象的内部类Memento实现了MementoIF接口，这个内部类是传入的备忘录对象的真实类型，因此发起人对象可以利用内部类Memento的私有接口读出此对象的内部状态。

　多重检查点

　　前面所给出的白箱和黑箱的示意性实现都是只存储一个状态的简单实现，也可以叫做只有一个检查点。常见的系统往往需要存储不止一个状态，而是需要存储多个状态，或者叫做有多个检查点。

　　备忘录模式可以将发起人对象的状态存储到备忘录对象里面，备忘录模式可以将发起人对象恢复到备忘录对象所存储的某一个检查点上。下面给出一个示意性的、有多重检查点的备忘录模式的实现。

　　源代码

　　发起人角色源代码

[java] view
plaincopyprint?

1. package com.bankht.Memento.Multiple;
2. import java.util.ArrayList;
3. import java.util.List;
4. /**
5. * @author: 特种兵—AK47
6. * @创建时间：2012-7-2 下午04:55:00
7. *
8. * @类说明 ：发起人角色源代码
9. */
10. public class Originator {
11. private List<String> states;
12. // 检查点指数
13. private int index;
14. /**
15. * 构造函数
16. */
17. public Originator() {
18. states = new ArrayList<String>();
19. index = 0;
20. }
21. /**
22. * 工厂方法，返还一个新的备忘录对象
23. */
24. public Memento createMemento() {
25. return new Memento(states, index);
26. }
27. /**
28. * 将发起人恢复到备忘录对象记录的状态上
29. */
30. public void restoreMemento(Memento memento) {
31. states = memento.getStates();
32. index = memento.getIndex();
33. }
34. /**
35. * 状态的赋值方法
36. */
37. public void setState(String state) {
38. states.add(state);
39. index++;
40. }
41. /**
42. * 辅助方法，打印所有状态
43. */
44. public void printStates() {
45. System.out.println("检查点共有："+states.size()+"个");
46. for (String state : states) {
47. System.out.println(state);
48. }
49. }
50. }

　　备忘录角色类，这个实现可以存储任意多的状态，外界可以使用检查点指数index来取出检查点上的状态。　

[java] view
plaincopyprint?

1. package com.bankht.Memento.Multiple;
2. import java.util.ArrayList;
3. import java.util.List;
4. /**
5. * @author: 特种兵—AK47
6. * @创建时间：2012-7-2 下午04:55:23
7. *
8. * @类说明 ：备忘录角色类，这个实现可以存储任意多的状态，外界可以使用检查点指数index来取出检查点上的状态。　　
9. */
10. public class Memento {
11. private List<String> states;
12. private int index;
13. /**
14. * 构造函数
15. */
16. public Memento(List<String> states, int index) {
17. this.states = new ArrayList<String>(states);
18. this.index = index;
19. }
20. public List<String> getStates() {
21. return states;
22. }
23. public int getIndex() {
24. return index;
25. }
26. }

　　负责人角色类

[java] view
plaincopyprint?

1. package com.bankht.Memento.Multiple;
2. import java.util.ArrayList;
3. import java.util.List;
4. /**
5. * @author: 特种兵—AK47
6. * @创建时间：2012-7-2 下午04:56:08
7. *
8. * @类说明 ：负责人角色类
9. */
10. public class Caretaker {
11. private Originator o;
12. private List<Memento> mementos = new ArrayList<Memento>();
13. private int current;
14. /**
15. * 构造函数
16. */
17. public Caretaker(Originator o) {
18. this.o = o;
19. current = 0;
20. }
21. /**
22. * 创建一个新的检查点
23. */
24. public int createMemento() {
25. Memento memento = o.createMemento();
26. mementos.add(memento);
27. return current++;
28. }
29. /**
30. * 将发起人恢复到某个检查点
31. */
32. public void restoreMemento(int index) {
33. Memento memento = mementos.get(index);
34. o.restoreMemento(memento);
35. }
36. /**
37. * 将某个检查点删除
38. */
39. public void removeMemento(int index) {
40. mementos.remove(index);
41. }
42. }

　　客户端角色源代码

[java] view
plaincopyprint?

1. package com.bankht.Memento.Multiple;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午04:56:31
5. *
6. * @类说明 ：客户端角色源代码
7. */
8. public class Client {
9. public static void main(String[] args) {
10. Originator o = new Originator();
11. Caretaker c = new Caretaker(o);
12. // 改变状态
13. o.setState("state 0");
14. // 建立一个检查点
15. c.createMemento();
16. // 改变状态
17. o.setState("state 1");
18. // 建立一个检查点
19. c.createMemento();
20. // 改变状态
21. o.setState("state 2");
22. // 建立一个检查点
23. c.createMemento();
24. // 改变状态
25. o.setState("state 3");
26. // 建立一个检查点
27. c.createMemento();
28. // 打印出所有检查点
29. o.printStates();
30. System.out.println("-----------------恢复检查点-----------------");
31. // 恢复到第二个检查点
32. c.restoreMemento(2);
33. // 打印出所有检查点
34. o.printStates();
35. }
36. }

　运行结果如下：

[html] view
plaincopyprint?

1. 检查点共有：4个
2. state 0
3. state 1
4. state 2
5. state 3
6. -----------------恢复检查点-----------------
7. 检查点共有：3个
8. state 0
9. state 1
10. state 2

　　可以看出，客户端角色通过不断改变发起人角色的状态，并将之存储在备忘录里面。通过指明检查点指数可以将发起人角色恢复到相应的检查点所对应的状态上。

　　将发起人的状态存储到备忘录对象中的活动序列图如下：

　　系统运行的时序是这样的：

　　（1）将发起人对象的状态设置成某个有效状态；

　　（2）调用负责人角色的createMemento()方法，负责人角色会负责调用发起人角色和备忘录角色，将发起人对象的状态存储起来。

　　将发起人对象恢复到某一个备忘录对象的检查点的活动序列图如下：

　　由于负责人角色的功能被增强了，因此将发起人对象恢复到备忘录对象所记录的状态时，系统运行的时序被简化了：

　　（1）调用负责人角色的restoreMemento()方法，将发起人恢复到某个检查点。

　“自述历史”模式

　　所谓“自述历史”模式(History-On-Self Pattern)实际上就是备忘录模式的一个变种。在备忘录模式中，发起人(Originator)角色、负责人(Caretaker)角色和备忘录(Memento)角色都是独立的角色。虽然在实现上备忘录类可以成为发起人类的内部成员类，但是备忘录类仍然保持作为一个角色的独立意义。在“自述历史”模式里面，发起人角色自己兼任负责人角色。

　　“自述历史”模式的类图如下所示：

　　备忘录角色有如下责任：

　　（1）将发起人（Originator）对象的内部状态存储起来。

　　（2）备忘录可以保护其内容不被发起人（Originator）对象之外的任何对象所读取。

　　发起人角色有如下责任：

　　（1）创建一个含有它当前的内部状态的备忘录对象。

　　（2）使用备忘录对象存储其内部状态。

　　客户端角色有负责保存备忘录对象的责任。

　　源代码

　　窄接口MementoIF，这是一个标识接口，因此它没有定义出任何的方法。

[java] view
plaincopyprint?

1. package com.bankht.Memento.HistoryOnSelf;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午05:02:31
5. *
6. * @类说明 ：窄接口MementoIF，这是一个标识接口，因此它没有定义出任何的方法。
7. */
8. public interface MementoIF {
9. }

　发起人角色同时还兼任负责人角色，也就是说它自己负责保持自己的备忘录对象。

[java] view
plaincopyprint?

1. package com.bankht.Memento.HistoryOnSelf;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午05:02:57
5. *
6. * @类说明 ：发起人角色同时还兼任负责人角色，也就是说它自己负责保持自己的备忘录对象。
7. */
8. public class Originator {
9. public String state;
10. /**
11. * 改变状态
12. */
13. public void changeState(String state) {
14. this.state = state;
15. System.out.println("状态改变为：" + state);
16. }
17. /**
18. * 工厂方法，返还一个新的备忘录对象
19. */
20. public Memento createMemento() {
21. return new Memento(this);
22. }
23. /**
24. * 将发起人恢复到备忘录对象所记录的状态上
25. */
26. public void restoreMemento(MementoIF memento) {
27. Memento m = (Memento) memento;
28. changeState(m.state);
29. }
30. private class Memento implements MementoIF {
31. private String state;
32. /**
33. * 构造方法
34. */
35. private Memento(Originator o) {
36. this.state = o.state;
37. }
38. private String getState() {
39. return state;
40. }
41. }
42. }

　客户端角色类

[java] view
plaincopyprint?

1. package com.bankht.Memento.HistoryOnSelf;
2. /**
3. * @author: 特种兵—AK47
4. * @创建时间：2012-7-2 下午05:03:29
5. *
6. * @类说明 ：客户端角色类
7. */
8. public class Client {
9. public static void main(String[] args) {
10. Originator o = new Originator();
11. // 修改状态
12. o.changeState("state 0");
13. // 创建备忘录
14. MementoIF memento = o.createMemento();
15. // 修改状态
16. o.changeState("state 1");
17. // 按照备忘录恢复对象的状态
18. o.restoreMemento(memento);
19. }
20. }

　　由于“自述历史”作为一个备忘录模式的特殊实现形式非常简单易懂，它可能是备忘录模式最为流行的实现形式。

本文参考内容：http://blog.csdn.net/m13666368773/article/details/7709156

中文版的  java设计模式第二版

版权声明：欢迎转载，希望在你转载的同时，添加原文地址，谢谢配合