设计模式 21 备忘录模式 Memento Pattern
1.定义
备忘录模式是一种行为型设计模式,它允许你将一个对象的状态保存到一个独立的“备忘录”对象中,并在之后恢复到该状态。
2.内涵
主要用于以下场景:
需要保存对象状态以备恢复: 当你想要在进行一些可能导致对象状态改变的操作之前,先保存对象当前状态,以便在操作失败或需要撤销操作时能够恢复到之前的状态。
需要提供撤销/重做功能: 备忘录模式可以用来实现撤销和重做功能,通过保存一系列状态,用户可以回退到之前的操作步骤。
需要将对象状态序列化: 备忘录模式可以将对象状态序列化到一个独立的对象中,方便存储或传输。
主要模块如下:
- 发起者(Originator): 需要保存状态的对象。
- 备忘录(Memento): 保存发起者状态的对象。
- 守护者(Caretaker): 负责管理备忘录对象,通常会保存多个备忘录,以便实现撤销/重做功能。
解释:
Originator 对象拥有一个 createMemento() 方法,用于创建 Memento 对象并保存自身状态。同时,它也拥有一个 setMemento() 方法,用于从 Memento 对象中恢复自身状态。
Memento 对象保存了 Originator 对象的状态,并且只允许 Originator 对象访问其内部状态。
Caretaker 对象负责管理 Memento 对象,它拥有 addMemento() 和 getMemento() 方法,分别用于添加和获取 Memento 对象。
类图关系:
Originator 对象与 Memento 对象之间存在关联关系,因为 Originator 对象创建并使用 Memento 对象。
Caretaker 对象与 Memento 对象之间也存在关联关系,因为 Caretaker 对象管理 Memento 对象。
3.案例分析
class Memento {public:virtual ~Memento() {}virtual std::string GetName() const = 0;virtual std::string date() const = 0;virtual std::string state() const = 0;
};/*** The Concrete Memento contains the infrastructure for storing the Originator's* state.*/
class ConcreteMemento : public Memento {private:std::string state_;std::string date_;public:ConcreteMemento(std::string state) : state_(state) {this->state_ = state;std::time_t now = std::time(0);this->date_ = std::ctime(&now);}/*** The Originator uses this method when restoring its state.*/std::string state() const override {return this->state_;}/*** The rest of the methods are used by the Caretaker to display metadata.*/std::string GetName() const override {return this->date_ + " / (" + this->state_.substr(0, 9) + "...)";}std::string date() const override {return this->date_;}
};/*** The Originator holds some important state that may change over time. It also* defines a method for saving the state inside a memento and another method for* restoring the state from it.*/
class Originator {/*** @var string For the sake of simplicity, the originator's state is stored* inside a single variable.*/private:std::string state_;std::string GenerateRandomString(int length = 10) {const char alphanum[] ="0123456789""ABCDEFGHIJKLMNOPQRSTUVWXYZ""abcdefghijklmnopqrstuvwxyz";int stringLength = sizeof(alphanum) - 1;std::string random_string;for (int i = 0; i < length; i++) {random_string += alphanum[std::rand() % stringLength];}return random_string;}public:Originator(std::string state) : state_(state) {std::cout << "Originator: My initial state is: " << this->state_ << "\n";}/*** The Originator's business logic may affect its internal state. Therefore,* the client should backup the state before launching methods of the business* logic via the save() method.*/void DoSomething() {std::cout << "Originator: I'm doing something important.\n";this->state_ = this->GenerateRandomString(30);std::cout << "Originator: and my state has changed to: " << this->state_ << "\n";}/*** Saves the current state inside a memento.*/Memento *Save() {return new ConcreteMemento(this->state_);}/*** Restores the Originator's state from a memento object.*/void Restore(Memento *memento) {this->state_ = memento->state();std::cout << "Originator: My state has changed to: " << this->state_ << "\n";}
};/*** The Caretaker doesn't depend on the Concrete Memento class. Therefore, it* doesn't have access to the originator's state, stored inside the memento. It* works with all mementos via the base Memento interface.*/
class Caretaker {/*** @var Memento[]*/private:std::vector<Memento *> mementos_;/*** @var Originator*/Originator *originator_;public:Caretaker(Originator* originator) : originator_(originator) {}~Caretaker() {for (auto m : mementos_) delete m;}void Backup() {std::cout << "\nCaretaker: Saving Originator's state...\n";this->mementos_.push_back(this->originator_->Save());}void Undo() {if (!this->mementos_.size()) {return;}Memento *memento = this->mementos_.back();this->mementos_.pop_back();std::cout << "Caretaker: Restoring state to: " << memento->GetName() << "\n";try {this->originator_->Restore(memento);} catch (...) {this->Undo();}}void ShowHistory() const {std::cout << "Caretaker: Here's the list of mementos:\n";for (Memento *memento : this->mementos_) {std::cout << memento->GetName() << "\n";}}
};/*** Client code.*/void ClientCode() {Originator *originator = new Originator("Super-duper-super-puper-super.");Caretaker *caretaker = new Caretaker(originator);caretaker->Backup();originator->DoSomething();caretaker->Backup();originator->DoSomething();caretaker->Backup();originator->DoSomething();std::cout << "\n";caretaker->ShowHistory();std::cout << "\nClient: Now, let's rollback!\n\n";caretaker->Undo();std::cout << "\nClient: Once more!\n\n";caretaker->Undo();delete originator;delete caretaker;
}int main() {std::srand(static_cast<unsigned int>(std::time(NULL)));ClientCode();return 0;
}
4.注意事项
备忘录模式在使用时需要注意以下几点:
1. 备忘录的封装性:
备忘录对象应该封装 Originator 的内部状态,并对外部隐藏这些状态。这意味着 Caretaker 只能通过 Originator 提供的接口来访问备忘录对象,而不能直接访问备忘录对象内部的状态。
这可以防止 Caretaker 意外修改 Originator 的状态,并确保状态的一致性。
2. 备忘录的管理:Caretaker 应该负责管理备忘录对象,例如存储、检索和删除备忘录。
Caretaker 应该提供方法来添加、获取和删除备忘录,以便 Originator 可以方便地保存和恢复其状态。
3. 备忘录的性能:创建和存储备忘录对象可能会消耗一定的资源,因此需要考虑性能问题。
可以通过使用轻量级的备忘录对象或使用缓存机制来提高性能。
4. 备忘录的安全性:备忘录对象可能包含敏感信息,因此需要考虑安全性问题。
可以使用加密或访问控制机制来保护备忘录对象。
5. 备忘录的使用场景:备忘录模式适用于需要保存和恢复对象状态的场景,例如撤销/重做功能、游戏存档和恢复等。
需要根据具体场景选择合适的备忘录实现方式,例如使用简单的数据结构或使用更复杂的序列化机制。
5.最佳实践
在使用备忘录模式时,以下是一些值得遵循的经验:
1. 保持备忘录的简单性:
备忘录对象应该只包含 Originator 状态的必要信息,避免过度复杂化。
尽量使用简单的数据结构来存储状态,例如字典、列表等,避免使用复杂的自定义对象。
2. 使用工厂模式创建备忘录:使用工厂模式可以简化备忘录对象的创建过程,并隐藏备忘录对象的具体实现细节。
工厂模式可以根据不同的场景创建不同的备忘录对象,例如创建不同的备忘录类型来保存不同的状态信息。
3. 使用策略模式管理备忘录:使用策略模式可以根据不同的需求选择不同的备忘录管理策略,例如使用不同的存储方式或不同的访问控制机制。
策略模式可以提高代码的可扩展性和灵活性,方便根据需求进行修改和扩展。
4. 使用缓存机制提高性能:可以使用缓存机制来存储最近使用的备忘录对象,避免重复创建备忘录对象。
缓存机制可以提高性能,尤其是在频繁保存和恢复状态的场景下。
5. 使用序列化机制保存备忘录:可以使用序列化机制将备忘录对象保存到文件或数据库中,以便持久化保存状态。
序列化机制可以方便地保存和恢复状态,并支持跨平台使用。
6. 考虑安全性问题:如果备忘录对象包含敏感信息,需要考虑安全性问题,例如使用加密或访问控制机制来保护备忘录对象。
可以使用安全策略来限制对备忘录对象的访问权限,并确保信息的安全性。
6.总结
备忘录模式是一种强大的设计模式,可以帮助我们实现状态的保存和恢复功能。在使用备忘录模式时,需要注意封装性、管理、性能、安全性以及使用场景等方面,以确保其有效性和安全性。