Java设计模式之备忘录模式_动力节点Java学院

定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存的状态

类型：行为类

类图：

        我们在编程的时候，经常需要保存对象的中间状态，当需要的时候，可以恢复到这个状态。比如，我们使用eclipse进行编程时，假如编写失误（例如不小心误删除了几行代码），我们希望返回删除前的状态，便可以使用ctrl+z来进行返回。这时我们便可以使用备忘录模式来实现。

备忘录模式的结构

• 发起人：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
• 备忘录：负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。
• 管理角色：对备忘录进行管理，保存和提供备忘录。

通用代码实现

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容器才存储所有的备份。下面我们给出一个多状态多备份的例子：

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恢复等。

总结

以上所述是小编给大家介绍的java设计模式之备忘录模式_动力节点java学院，希望对大家有所帮助