[设计模式]行为型-备忘录模式
简介备忘录模式(Memento Pattern)是一种行为型设计模式，它允许生成对象状态的快照并在以后将其还原。备忘录模式不会影响它所处理对象的内部结构，也不会影响快照中存储的数据。简单来说，它就像游戏中的“保存”和“加载”功能。
组成角色：
[*]Originator（发起人）： 主要用于生成自身状态的快照，在需要时可以通过快照恢复自身状态。
[*]Memento（备忘录）： 一个对象，用于存储Originator在某个特定时间点的内部状态。备忘录对Originator之外的对象是不可见的，这样可以保护Originator的状态不被外部修改。通常将备忘录类设置为不可变的类，并且通过构造函数一次性传递数据。
[*]Caretaker（管理者）： 负责保存和管理备忘录对象，但不检查备忘录的内容，只知道何时和为何捕捉Originator的状态，以及何时恢复Originator的状态。
常见使用场景
[*]撤销/重做功能： 许多应用程序（如文本编辑器、图形编辑器）都提供了撤销和重做操作。备忘录模式可以用来保存每次操作之前的状态，以便进行撤销。
[*]事务管理： 在某些事务处理系统中，可能需要在事务失败时回滚到之前的状态。备忘录模式可以用来保存事务开始前的状态。
[*]程序状态的快照和恢复： 有时需要定期保存程序的状态，以便在出现问题时能够恢复到最近的稳定状态。
[*]游戏中的保存和加载： 游戏通常需要保存玩家的进度，并在需要时加载。备忘录模式非常适合这种场景。
优点
[*]封装性好： Originator的状态被封装在Memento中，对外部不可见，保证了状态的安全性。
[*]简化了Originator： Originator只需要负责创建和恢复备忘录，而不需要关心备忘录的管理。备忘录的管理交由Caretaker负责。
[*]支持历史版本： 可以保存Originator的多个历史状态，方便进行多次撤销或恢复。
缺点
[*]内存消耗： 如果需要保存的状态很多或者状态很大，可能会消耗大量的内存。
[*]管理复杂性： Caretaker需要管理多个备忘录对象，可能会增加管理的复杂性。
[*]状态恢复的性能开销： 恢复状态可能涉及到复杂的数据复制操作，可能会有一定的性能开销。
示例代码
Simple
Go
package memento
type Memento struct {
state int
}
func NewMemento(value int) *Memento {
return &Memento{
state: value,
}
}
type Originator struct {
value int
}
func NewOriginator(value int) *Originator {
return &Originator{
value: value,
}
}
func (o *Originator) TenTimes() {
o.value *= 10
}
func (o *Originator) HalfTimes() {
o.value /= 2
}
func (o *Originator) Value() int {
return o.value
}
func (o *Originator) CreateMemento() *Memento {
return NewMemento(o.value)
}
func (o *Originator) RestoreMemento(m *Memento) {
o.value = m.state
}
type Caretaker struct {
Mementos []*Memento
}
func (c *Caretaker) AddMemento(m *Memento) {
c.Mementos = append(c.Mementos, m)
}
func (c *Caretaker) GetMemento(index int) *Memento {
return c.Mementos
}客户端
package memento
import (
"fmt"
"testing"
)
func TestSimple(t *testing.T) {
caretaker := &Caretaker{
Mementos: make([]*Memento, 0),
}
n := NewOriginator(10)
caretaker.AddMemento(n.CreateMemento())
n.TenTimes()
fmt.Printf("Current value: %d\n", n.Value())
caretaker.AddMemento(n.CreateMemento())
n.TenTimes()
fmt.Printf("Current value: %d\n", n.Value())
n.RestoreMemento(caretaker.GetMemento(0))
fmt.Printf("Current value after restore: %d\n", n.Value())
}执行输出
Current value: 100
Current value: 1000
Current value after restore: 10Python
from typing import List
class Memento:
"""
备忘录类
"""
def __init__(self, value: int):
self._value = value
@property
def value(self) -> int:
"""用 property 实现属性只读"""
return self._value
class Originator:
"""
发起人类
"""
def __init__(self, value: int):
self._value = value
def ten_times(self):
self._value *= 10
def half_times(self):
self._value /= 2
def get_value(self) -> int:
return self._value
def create_memento(self) -> Memento:
return Memento(self._value)
def restore_memento(self, memento: Memento):
self._value = memento.value
class Caretaker:
"""负责人类"""
def __init__(self):
self._mems: List = []
def add_memento(self, memento: Memento):
self._mems.append(memento)
def get_memento(self, index: int) -> Memento:
return self._mems
if __name__ == "__main__":
caretaker = Caretaker()
n = Originator(10)
caretaker.add_memento(n.create_memento())
n.ten_times()
print(f"current value: {n.get_value()}")
caretaker.add_memento(n.create_memento())
n.ten_times()
print(f"current value: {n.get_value()}")
n.restore_memento(caretaker.get_memento(0))
print(f"current value after restore: {n.get_value()}")执行输出
current value: 100
current value: 1000
current value after restore: 10
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]