Memento模式

Memento模式，究其根源来说是一种记录模式，记录用户之前所做的操作，然后可以为用户提供undo功能，即撤销，用术语来说呢，就是在不破坏要记录类的封装的前提下，捕

捉类的一个内部状态，这样通过对该状态的保存提供恢复操作的功能，Memento模式示意图如下：

Original类会有getState和setState存取状态函数，对于状态的保存，则有createMem和RestoreToMem函数，进行状态的保存和恢复，

#include"iostream"
using namespace std;
class Memeno ;
class Original
{
private:
    string _state;
    Memeno* _mem;
public:
   Original(string tmp)
    {_state=tmp;}
   string getState()
   {  return _state;}
   void   setState(string _st)
   {_state=_st;}
   Memeno* createMem()
    { return _Mem=new Memeno(_state);}
   void RestorToMem()
    {this->_state=_Mem->_state;} 
    void PrintState()
    {cout<<this->_state;}   
};
class Memeno
{
    private:
   string _state;
   public:
    string getState()
   {return _state;}
    void setState(string tmp) 
   {_state=tmp;   }
};
int main()
{
   Original* ori=new Original("old");  
   Memeno *mem=ori->createMem();
   ori->PrintInfo();
   ori->setState("new");
   ori->PrintInfo();
   ori->RestorToMem();
   ori->PrintInfo();
}
</this->

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

类型：行为类

类图：

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

 

备忘录模式的结构

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

 

通用代码实现

[java] view plain copy

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

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