设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

详解Java设计模式之备忘录模式的使用

2016-8-16 12:49| 发布者: zhangjf| 查看: 625| 评论: 0

摘要: 定义与结构　 备忘录（Memento）模式又称标记（Token）模式。GOF给备忘录模式的定义为：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状 ...

定义与结构　

备忘录（Memento）模式又称标记（Token）模式。GOF给备忘录模式的定义为：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

　　在讲命令模式的时候，我们曾经提到利用中间的命令角色可以实现undo、redo的功能。从定义可以看出备忘录模式是专门来存放对象历史状态的，这对于很好的实现undo、redo功能有很大的帮助。所以在命令模式中undo、redo功能可以配合备忘录模式来实现。

　　其实单就实现保存一个对象在某一时刻的状态的功能，还是很简单的——将对象中要保存的属性放到一个专门管理备份的对象中，需要的时候则调用约定好的方法将备份的属性放回到原来的对象中去。但是你要好好看看为了能让你的备份对象访问到原对象中的属性，是否意味着你就要全部公开或者包内公开对象原本私有的属性呢？如果你的做法已经破坏了封装，那么就要考虑重构一下了。

　　备忘录模式只是GOF对“恢复对象某时的原有状态”这一问题提出的通用方案。因此在如何保持封装性上——由于受到语言特性等因素的影响，备忘录模式并没有详细描述，只是基于C++阐述了思路。


　　1) 备忘录（Memento）角色：备忘录角色存储“备忘发起角色”的内部状态。“备忘发起角色”根据需要决定备忘录角色存储“备忘发起角色”的哪些内部状态。为了防止“备忘发起角色”以外的其他对象访问备忘录。备忘录实际上有两个接口，“备忘录管理者角色”只能看到备忘录提供的窄接口——对于备忘录角色中存放的属性是不可见的。“备忘发起角色”则能够看到一个宽接口——能够得到自己放入备忘录角色中属性。

　　2) 备忘发起（Originator）角色：“备忘发起角色”创建一个备忘录，用以记录当前时刻它的内部状态。在需要时使用备忘录恢复内部状态。

　　3) 备忘录管理者（Caretaker）角色：负责保存好备忘录。不能对备忘录的内容进行操作或检查。

　　备忘录模式的类图真是再简单不过了：

2016217112919585.jpg (518×47)

通用代码实现

  2. class Originator {
  3. private String state = "";
  5. public String getState() {
  6. return state;
  7. }
  8. public void setState(String state) {
  9. this.state = state;
  10. }
  11. public Memento createMemento(){
  12. return new Memento(this.state);
  13. }
  14. public void restoreMemento(Memento memento){
  15. this.setState(memento.getState());
  16. }
  17. }
  19. class Memento {
  20. private String state = "";
  21. public Memento(String state){
  22. this.state = state;
  23. }
  24. public String getState() {
  25. return state;
  26. }
  27. public void setState(String state) {
  28. this.state = state;
  29. }
  30. }
  31. class Caretaker {
  32. private Memento memento;
  33. public Memento getMemento(){
  34. return memento;
  35. }
  36. public void setMemento(Memento memento){
  37. this.memento = memento;
  38. }
  39. }
  40. public class Client {
  41. public static void main(String[] args){
  42. Originator originator = new Originator();
  43. originator.setState("状态1");
  44. System.out.println("初始状态:"+originator.getState());
  45. Caretaker caretaker = new Caretaker();
  46. caretaker.setMemento(originator.createMemento());
  47. originator.setState("状态2");
  48. System.out.println("改变后状态:"+originator.getState());
  49. originator.restoreMemento(caretaker.getMemento());
  50. System.out.println("恢复后状态:"+originator.getState());
  51. }
  52. }
复制代码

代码演示了一个单状态单备份的例子，逻辑非常简单：Originator类中的state变量需要备份，以便在需要的时候恢复；Memento类中，也有一个state变量，用来存储Originator类中state变量的临时状态；而Caretaker类就是用来管理备忘录类的，用来向备忘录对象中写入状态或者取回状态。

多状态多备份备忘录
 通用代码演示的例子中，Originator类只有一个state变量需要备份，而通常情况下，发起人角色通常是一个javaBean，对象中需要备份的变量不止一个，需要备份的状态也不止一个，这就是多状态多备份备忘录。实现备忘录的方法很多，备忘录模式有很多变形和处理方式，像通用代码那样的方式一般不会用到，多数情况下的备忘录模式，是多状态多备份的。其实实现多状态多备份也很简单，最常用的方法是，我们在Memento中增加一个Map容器来存储所有的状态，在Caretaker类中同样使用一个Map容器才存储所有的备份。下面我们给出一个多状态多备份的例子：

  2. class Originator {
  3. private String state1 = "";
  4. private String state2 = "";
  5. private String state3 = "";
  7. public String getState1() {
  8. return state1;
  9. }
  10. public void setState1(String state1) {
  11. this.state1 = state1;
  12. }
  13. public String getState2() {
  14. return state2;
  15. }
  16. public void setState2(String state2) {
  17. this.state2 = state2;
  18. }
  19. public String getState3() {
  20. return state3;
  21. }
  22. public void setState3(String state3) {
  23. this.state3 = state3;
  24. }
  25. public Memento createMemento(){
  26. return new Memento(BeanUtils.backupProp(this));
  27. }
  29. public void restoreMemento(Memento memento){
  30. BeanUtils.restoreProp(this, memento.getStateMap());
  31. }
  32. public String toString(){
  33. return "state1="+state1+"state2="+state2+"state3="+state3;
  34. }
  35. }
  36. class Memento {
  37. private Map<String, Object> stateMap;
  39. public Memento(Map<String, Object> map){
  40. this.stateMap = map;
  41. }
  43. public Map<String, Object> getStateMap() {
  44. return stateMap;
  45. }
  47. public void setStateMap(Map<String, Object> stateMap) {
  48. this.stateMap = stateMap;
  49. }
  50. }
  51. class BeanUtils {
  52. public static Map<String, Object> backupProp(Object bean){
  53. Map<String, Object> result = new HashMap<String, Object>();
  54. try{
  55. BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
  56. PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
  57. for(PropertyDescriptor des: descriptors){
  58. String fieldName = des.getName();
  59. Method getter = des.getReadMethod();
  60. Object fieldValue = getter.invoke(bean, new Object[]{});
  61. if(!fieldName.equalsIgnoreCase("class")){
  62. result.put(fieldName, fieldValue);
  63. }
  64. }
  66. }catch(Exception e){
  67. e.printStackTrace();
  68. }
  69. return result;
  70. }
  72. public static void restoreProp(Object bean, Map<String, Object> propMap){
  73. try {
  74. BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
  75. PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
  76. for(PropertyDescriptor des: descriptors){
  77. String fieldName = des.getName();
  78. if(propMap.containsKey(fieldName)){
  79. Method setter = des.getWriteMethod();
  80. setter.invoke(bean, new Object[]{propMap.get(fieldName)});
  81. }
  82. }
  83. } catch (Exception e) {
  84. e.printStackTrace();
  85. }
  86. }
  87. }
  88. class Caretaker {
  89. private Map<String, Memento> memMap = new HashMap<String, Memento>();
  90. public Memento getMemento(String index){
  91. return memMap.get(index);
  92. }
  94. public void setMemento(String index, Memento memento){
  95. this.memMap.put(index, memento);
  96. }
  97. }
  98. class Client {
  99. public static void main(String[] args){
  100. Originator ori = new Originator();
  101. Caretaker caretaker = new Caretaker();
  102. ori.setState1("中国");
  103. ori.setState2("强盛");
  104. ori.setState3("繁荣");
  105. System.out.println("===初始化状态===n"+ori);
  107. caretaker.setMemento("001",ori.createMemento());
  108. ori.setState1("软件");
  109. ori.setState2("架构");
  110. ori.setState3("优秀");
  111. System.out.println("===修改后状态===n"+ori);
  113. ori.restoreMemento(caretaker.getMemento("001"));
  114. System.out.println("===恢复后状态===n"+ori);
  115. }
  116. }
复制代码

备忘录模式的优缺点和适用场景
备忘录模式的优点有：
当发起人角色中的状态改变时，有可能这是个错误的改变，我们使用备忘录模式就可以把这个错误的改变还原。
备份的状态是保存在发起人角色之外的，这样，发起人角色就不需要对各个备份的状态进行管理。
备忘录模式的缺点：
在实际应用中，备忘录模式都是多状态和多备份的，发起人角色的状态需要存储到备忘录对象中，对资源的消耗是比较严重的。
如果有需要提供回滚操作的需求，使用备忘录模式非常适合，比如jdbc的事务操作，文本编辑器的Ctrl+Z恢复等。

收藏 邀请
上一篇：解析Java的设计模式编程之解释器模式的运用下一篇：学习Java中的日期和时间处理及Java日历小程序的编写

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-6 15:37

Copyright 2015-2025 djqfx

返回顶部