备忘录模式（Memento Pattern）

概念

备忘录模式是一种行为设计模式，它允许在不破坏封装性的前提下捕获和恢复对象的内部状态。该模式用于将对象的状态保存到外部，并在需要时将其恢复回去。

思想

备忘录模式通过引入备忘录对象，允许在不暴露对象实现细节的情况下保存和恢复其状态。原始对象（发起人）创建一个备忘录对象，它包含原始对象的内部状态。备忘录对象可以由外部对象（管理者）持有，并在需要时传递给原始对象以进行状态恢复。

角色

1. Originator（发起人）：需要被保存和恢复状态的对象。它创建备忘录对象并可以从备忘录中恢复状态。
2. Memento（备忘录）：存储原始对象的内部状态。它可以包含一个或多个备忘录属性。
3. Caretaker（管理者）：负责保存备忘录对象，并在需要时将其提供给原始对象进行状态恢复。
4. Client（客户端）：与发起人对象和管理者对象进行交互，触发备忘录的创建和恢复。

优点

• 可以在不破坏封装性的前提下实现对象的状态保存和恢复。
• 允许对对象的状态进行快照，并在需要时进行回滚操作。
• 可以简化原始对象的实现，将状态管理交给备忘录和管理者对象。

缺点

• 如果原始对象的状态较大或者包含敏感信息，备忘录的创建和恢复可能会消耗较多的资源。
• 需要额外的代码实现备忘录和管理者对象，增加了系统的复杂性。

类图

@startuml
class Originator {
  - state: String
  + setState(state: String): void
  + getState(): String
  + createMemento(): Memento
  + restoreMemento(memento: Memento): void
}
class Memento {
  - state: String
  + getState(): String
}
class Caretaker {
  - mementos: List<Memento>
  + addMemento(memento: Memento): void
  + getMemento(index: int): Memento
}
class Client {
  + main(): void
}

Originator --> Memento
Originator --> Caretaker
Client --> Originator
Client --> Caretaker
@enduml

时序图

@startuml
hide footbox
title 备忘录模式 - 时序图

participant Client
participant Originator
participant Caretaker
participant Memento

Client -> Originator: setState("State 1")
Client -> Originator: setState("State 2")
Client -> Caretaker: addMemento(memento1)
Originator -> Memento: getState()
Caretaker -> Memento: getState()
Caretaker -> Originator: createMemento()
Client -> Originator: setState("State 3")
Client -> Caretaker: addMemento(memento2)
Originator -> Memento: getState()
Caretaker -> Memento: getState()
Caretaker -> Originator: createMemento()
Client -> Originator: restoreMemento(memento1)
Originator -> Memento: getState()
Originator -> Caretaker: restoreMemento(memento1)
Caretaker -> Memento: getState()

@enduml

示例代码

下面是一个使用C++实现备忘录模式的简单示例代码：

#include <iostream>
#include <string>
#include <vector>

class Memento {
private:
    std::string state;

public:
    Memento(const std::string& state) : state(state) {}

    std::string getState() const {
        return state;
    }
};

class Originator {
private:
    std::string state;

public:
    void setState(const std::string& state) {
        this->state = state;
    }

    std::string getState() const {
        return state;
    }

    Memento createMemento() {
        return Memento(state);
    }

    void restoreMemento(const Memento& memento) {
        state = memento.getState();
    }
};

class Caretaker {
private:
    std::vector<Memento> mementos;

public:
    void addMemento(const Memento& memento) {
        mementos.push_back(memento);
    }

    Memento getMemento(int index) const {
        return mementos[index];
    }
};

int main() {
    Originator originator;
    Caretaker caretaker;

    originator.setState("State 1");
    originator.setState("State 2");
    caretaker.addMemento(originator.createMemento());

    originator.setState("State 3");
    caretaker.addMemento(originator.createMemento());

    originator.restoreMemento(caretaker.getMemento(0));

    std::cout << "Current state: " << originator.getState() << std::endl;

    return 0;
}

代码运行结果：

Current state: State 2

上述示例代码中，客户端（Client）通过与发起人（Originator）和管理者（Caretaker）进行交互，演示了备忘录模式的基本流程。首先，客户端设置发起人的状态，并创建一个备忘录（Memento），并将备忘录保存到管理者中。然后，客户端修改发起人的状态，并再次创建一个备忘录并保存到管理者中。最后，客户端从管理者中获取第一个备忘录，并将其恢复到发起人中，输出当前状态为 "State 2"。这样，备忘录模式成功地保存了发起人对象的状态并实现了状态的恢复。