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

简介

备忘录模式(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[index]
}

客户端

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: 10

Python

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[Memento] = []

    def add_memento(self, memento: Memento):
        self._mems.append(memento)

    def get_memento(self, index: int) -> Memento:
        return self._mems[index]


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