[设计模式] 设计模式课程（十六）-- 备忘录模式（Memento）

概述

• 也叫快照（SnapShot）
• 属于行为类设计模式
• 允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态
• 软件构建过程中，某些对象的状态在转换过程中，可能由于某种需要，要求程序能回溯到对象之前处于某个点时的状态，如果使用一些公有接口来让其他对象得到对象的状态，便会暴露对象的细节实现
• 如何实现对象状态的良好保存与恢复，但同时又不会因此而破坏对象本身的封装性
• 在不破坏封装性的前提下，捕捉一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可以将该对象恢复到原先保存的状态
• 备忘录（Memento）存储原发器（Originator）对象的内部状态，在需要时恢复原发器状态
• Memento模式的核心是信息隐藏，即Originator需要向外接隐藏信息，保持其封装性，但同时又需要将状态保持到外界（Memento）
• 由于现代语言（Java，C#）运行时，都具有相当的序列化支持，因此往往用效率较高，又较容易正确实现的序列化方案来实现Memento模式

结构1

• 原发器类：用于获取状态，生成备忘录对象（快照），并在需要时通过快照恢复状态
• 备忘录类：用于保存状态，通常将备忘录设为不可变的，同通过构造函数一次性传递数据
• 负责人类：仅知道“何时”及“为何”捕捉原发器的状态，以及何时恢复状态，通过备忘录栈记录原发器的历史状态，当原发器要追溯历史状态时，负责人获取栈顶备忘录，传递给原发器的恢复方法
• 备忘录类嵌套在原发器类中，原发器就可以访问备忘录的成员变量和方法

结构2

• 允许存在多种不同类型的原发器和备忘录，每种原发器都和其响应的备忘录类进行交互
• 负责人被禁止修改在备忘录中的状态，恢复方法被定义在了备忘录类中
• 每个备忘录与创建了自身的原发器连接，原发器将自己及状态传递给备忘录的构造函数

场景

• 开发一款文字编辑器应用，让用户可以撤销施加在文本上的任何操作。可让程序在执行前记录所有的对象状态，并将其保存下来，当用户以后撤销某个操作时，程序将从历史记录中获取最近的快照，然后恢复所有对象的状态

联系

• 同时使用命令模式和备忘录模式实现撤销，命令用于对目标对象执行各种不同的操作，备忘录用于保存命令执行前对象的状态
• 同时使用备忘模式和迭代器模式获取当前迭代器的状态，并在需要时进行回滚
• 对象状态比较简单时，原型模式可以作为备忘录的一个简化版本

示例1

memento.cpp

class Memento
{
    string state;
    //..
public:
    Memento(const string & s) : state(s) {}
    string getState() const { return state; }
    void setState(const string & s) { state = s; }
};

class Originator
{
    string state;
    //....
public:
    Originator() {}
    Memento createMomento() {
        Memento m(state);
        return m;
    }
    void setMomento(const Memento & m) {
        state = m.getState();
    }
};

int main()
{
    Originator orginator;
    
    //捕获对象状态，存储到备忘录
    Memento mem = orginator.createMomento();
    
    //... 改变orginator状态
    
    //从备忘录中恢复
    orginator.setMomento(memento);
    
}

示例2

// 原发器中包含了一些可能会随时间变化的重要数据。它还定义了在备忘录中保存
// 自身状态的方法，以及从备忘录中恢复状态的方法。
class Editor is
    private field text, curX, curY, selectionWidth

    method setText(text) is
        this.text = text

    method setCursor(x, y) is
        this.curX = curX
        this.curY = curY

    method setSelectionWidth(width) is
        this.selectionWidth = width

    // 在备忘录中保存当前的状态。
    method createSnapshot():Snapshot is
        // 备忘录是不可变的对象；因此原发器会将自身状态作为参数传递给备忘
        // 录的构造函数。
        return new Snapshot(this, text, curX, curY, selectionWidth)

// 备忘录类保存有编辑器的过往状态。
class Snapshot is
    private field editor: Editor
    private field text, curX, curY, selectionWidth

    constructor Snapshot(editor, text, curX, curY, selectionWidth) is
        this.editor = editor
        this.text = text
        this.curX = curX
        this.curY = curY
        this.selectionWidth = selectionWidth

    // 在某一时刻，编辑器之前的状态可以使用备忘录对象来恢复。
    method restore() is
        editor.setText(text)
        editor.setCursor(curX, curY)
        editor.setSelectionWidth(selectionWidth)

// 命令对象可作为负责人。在这种情况下，命令会在修改原发器状态之前获取一个
// 备忘录。当需要撤销时，它会从备忘录中恢复原发器的状态。
class Command is
    private field backup: Snapshot

    method makeBackup() is
        backup = editor.createSnapshot()

    method undo() is
        if (backup != null)
            backup.restore()
    // ...

示例3

#include <string>
#include <vector>
#include <iostream>
#include <ctime>
using namespace std;

class Memento{
    public:
        virtual string GetName() const = 0;
        virtual string date() const = 0;
        virtual string state() const = 0;
};

class ConcreteMemento:public Memento{
    private:
        string state_;
        string date_;
    public:
        ConcreteMemento(string state):state_(state){
            this->state_ = state;
            time_t now = time(0);
            this->date_ = ctime(&now);
        }
        string state() const override{
            return this->state_;
        }    
        string GetName() const override{
            return this->date_ + "/(" + this->state_.substr(0,9)+"...)";
        }
        string date() const override{
            return this->date_;
        }
};

class Originator{
    private:
        string state_;
        string GenereateRandomString(int length = 10){
            const char alphanum[] = 
                "0123456789"
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                "abcdefghijklmnopqrstuvwxyz";
            int stringLength = sizeof(alphanum) - 1;
            
            string random_string;
            for(int i = 0; i < length; i ++){
                random_string += alphanum[rand()%stringLength];
            }
            return random_string;
        }
    public:
        Originator(string state):state_(state){
            cout << "Originator: My initial state is: " << this->state_ << "
";
        }    
        
        void DoSomething(){
            cout << "Originator: I'm doing something important.
"; 
            this->state_ = this->GenereateRandomString(30);
            cout << "Originator: and my state has changed to: " << this->state_ << "
";
        }
        
        Memento *Save(){
            return new ConcreteMemento(this->state_);
        }
        
        void Restore(Memento *memento){
            this->state_ = memento->state();
            cout << "Originator: My state has changed to: " << this->state_ << "
";
        }
};

class Caretaker{
    private:
        vector<Memento *> mementos_;
        Originator *originator_;
    public:
        Caretaker(Originator *originator):originator_(originator){
            this->originator_ = originator;
        }
        
        void Backup(){
            cout << "
Caretaker: Saving Originator's state...
";
            this->mementos_.push_back(this->originator_->Save());
        }
        void Undo(){
            if(!this->mementos_.size()){
                return;
            }
            Memento *memento = this->mementos_.back();
            this->mementos_.pop_back();
            cout << "Caretaker: Restoring state to: " << memento->GetName() << "
";
            try{
                this->originator_->Restore(memento);
            }catch(...){
                this->Undo();
            }
        }
        void ShowHistory() const{
            cout << "Caretaker: Here's the list of mementos:
";
            for(Memento *memento : this->mementos_){
                cout << memento->GetName() << "
";
            }
        }
};

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();
    cout << "
";
    caretaker->ShowHistory();
    cout << "
Client: Now, let's rollback!

";
    caretaker->Undo();
    cout << "
Client: Once more!

";
    caretaker->Undo();
    delete originator;
    delete caretaker;
}

int main(){
    srand(static_cast<unsigned int>(time(NULL)));
    ClientCode();
    return 0;
}

参考

https://refactoringguru.cn/design-patterns/memento