设计模式探秘-21-备忘录模式

备忘录模式的学习与实践

模式定义

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

类图

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

优点

缺点

使用场景

  1. 需要保存和回数数据的相关状态场景。
  2. 提供一个可回滚的操作。
  3. 需要监控的副本场景中。
  4. 数据库连接的事物管理。

注意事项

  1. 备忘录的生命期。
  2. 备忘录的性能。

扩展

  1. clone方式的备忘录
  2. 多状态的备忘录
  3. 多备份的备忘录
  4. 封装性更好的备忘录

实践

简单实现

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
#include <iostream>

using namespace std;

typedef string State;

class Originator;

class Memento
{
public:
friend class Originator;

Memento();
Memento(const State &sdt);
~Memento()
{
}
void SetState(const State &sdt);
State GetState();
private:
State m_sSdt;
};

Memento::Memento()
{
}

Memento::Memento(const State &sdt)
{
m_sSdt = sdt;
}

State Memento::GetState()
{
return m_sSdt;
}

void Memento::SetState(const State &sdt)
{
m_sSdt = sdt;
}


class Originator
{
public:
Originator()
{
m_sSdt = "";
m_pMt = nullptr;
}
Originator(const State &sdt)
{
m_sSdt = sdt;
m_pMt = nullptr;
}
~Originator()
{
}
Memento *CreateMemento()
{
return new Memento(m_sSdt);
}
void RestoreToMemento(Memento *mt)
{
m_sSdt = mt->GetState();
}
State GetState()
{
return m_sSdt;
}
void SetState(const State &sdt)
{
m_sSdt = sdt;
}
void PrintState()
{
cout<<"Originator "<<__FUNCTION__<<" "<<m_sSdt<<endl;
}
private:
State m_sSdt;
Memento *m_pMt;
};


int main()
{
Originator *o = new Originator();
o->SetState("old");
o->PrintState();
Memento *m = o->CreateMemento();
o->SetState("new");
o->PrintState();
o->RestoreToMemento(m);
o->PrintState();
return 0;
}

参考资料

  1. 设计模式之禅
  2. GoF+23种设计模式解析