[设计模式]行为型-备忘录模式

简介

备忘录模式(Memento Pattern)是一种行为型设计模式，它允许生成对象状态的快照并在以后将其还原。备忘录模式不会影响它所处理对象的内部结构，也不会影响快照中存储的数据。简单来说，它就像游戏中的“保存”和“加载”功能。
组成角色：

• Originator（发起人）： 主要用于生成自身状态的快照，在需要时可以通过快照恢复自身状态。
  
• Memento（备忘录）： 一个对象，用于存储Originator在某个特定时间点的内部状态。备忘录对Originator之外的对象是不可见的，这样可以保护Originator的状态不被外部修改。通常将备忘录类设置为不可变的类，并且通过构造函数一次性传递数据。
  
• Caretaker（管理者）： 负责保存和管理备忘录对象，但不检查备忘录的内容，只知道何时和为何捕捉Originator的状态，以及何时恢复Originator的状态。
  

常见使用场景

• 撤销/重做功能： 许多应用程序（如文本编辑器、图形编辑器）都提供了撤销和重做操作。备忘录模式可以用来保存每次操作之前的状态，以便进行撤销。
  
• 事务管理： 在某些事务处理系统中，可能需要在事务失败时回滚到之前的状态。备忘录模式可以用来保存事务开始前的状态。
  
• 程序状态的快照和恢复： 有时需要定期保存程序的状态，以便在出现问题时能够恢复到最近的稳定状态。
  
• 游戏中的保存和加载： 游戏通常需要保存玩家的进度，并在需要时加载。备忘录模式非常适合这种场景。
  

优点

• 封装性好： Originator的状态被封装在Memento中，对外部不可见，保证了状态的安全性。
  
• 简化了Originator： Originator只需要负责创建和恢复备忘录，而不需要关心备忘录的管理。备忘录的管理交由Caretaker负责。
  
• 支持历史版本： 可以保存Originator的多个历史状态，方便进行多次撤销或恢复。
  

缺点

• 内存消耗： 如果需要保存的状态很多或者状态很大，可能会消耗大量的内存。
  
• 管理复杂性： Caretaker需要管理多个备忘录对象，可能会增加管理的复杂性。
  
• 状态恢复的性能开销： 恢复状态可能涉及到复杂的数据复制操作，可能会有一定的性能开销。
  

示例代码

Simple

Go

1. package memento
3. type Memento struct {
4.         state int
5. }
7. func NewMemento(value int) *Memento {
8.         return &Memento{
9.                 state: value,
10.         }
11. }
13. type Originator struct {
14.         value int
15. }
17. func NewOriginator(value int) *Originator {
18.         return &Originator{
19.                 value: value,
20.         }
21. }
23. func (o *Originator) TenTimes() {
24.         o.value *= 10
25. }
27. func (o *Originator) HalfTimes() {
28.         o.value /= 2
29. }
31. func (o *Originator) Value() int {
32.         return o.value
33. }
35. func (o *Originator) CreateMemento() *Memento {
36.         return NewMemento(o.value)
37. }
39. func (o *Originator) RestoreMemento(m *Memento) {
40.         o.value = m.state
41. }
43. type Caretaker struct {
44.         Mementos []*Memento
45. }
47. func (c *Caretaker) AddMemento(m *Memento) {
48.         c.Mementos = append(c.Mementos, m)
49. }
51. func (c *Caretaker) GetMemento(index int) *Memento {
52.         return c.Mementos[index]
53. }

复制代码

客户端

1. package memento
3. import (
4.         "fmt"
5.         "testing"
6. )
8. func TestSimple(t *testing.T) {
9.         caretaker := &Caretaker{
10.                 Mementos: make([]*Memento, 0),
11.         }
13.         n := NewOriginator(10)
15.         caretaker.AddMemento(n.CreateMemento())
16.         n.TenTimes()
17.         fmt.Printf("Current value: %d\n", n.Value())
19.         caretaker.AddMemento(n.CreateMemento())
20.         n.TenTimes()
21.         fmt.Printf("Current value: %d\n", n.Value())
23.         n.RestoreMemento(caretaker.GetMemento(0))
24.         fmt.Printf("Current value after restore: %d\n", n.Value())
25. }

复制代码

执行输出

1. Current value: 100
2. Current value: 1000
3. Current value after restore: 10

复制代码

Python

1. from typing import List
4. class Memento:
5.     """
6.     备忘录类
7.     """
9.     def __init__(self, value: int):
10.         self._value = value
12.     @property
13.     def value(self) -> int:
14.         """用 property 实现属性只读"""
15.         return self._value
18. class Originator:
19.     """
20.     发起人类
21.     """
23.     def __init__(self, value: int):
24.         self._value = value
26.     def ten_times(self):
27.         self._value *= 10
29.     def half_times(self):
30.         self._value /= 2
32.     def get_value(self) -> int:
33.         return self._value
35.     def create_memento(self) -> Memento:
36.         return Memento(self._value)
38.     def restore_memento(self, memento: Memento):
39.         self._value = memento.value
42. class Caretaker:
43.     """负责人类"""
45.     def __init__(self):
46.         self._mems: List[Memento] = []
48.     def add_memento(self, memento: Memento):
49.         self._mems.append(memento)
51.     def get_memento(self, index: int) -> Memento:
52.         return self._mems[index]
55. if __name__ == "__main__":
56.     caretaker = Caretaker()
58.     n = Originator(10)
59.     caretaker.add_memento(n.create_memento())
60.     n.ten_times()
61.     print(f"current value: {n.get_value()}")
63.     caretaker.add_memento(n.create_memento())
64.     n.ten_times()
65.     print(f"current value: {n.get_value()}")
67.     n.restore_memento(caretaker.get_memento(0))
68.     print(f"current value after restore: {n.get_value()}")

复制代码

执行输出

1. current value: 100
2. current value: 1000
3. current value after restore: 10

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！