20.备忘录模式(行为型)

备忘录模式(行为型)

原书链接设计模式(刘伟)

一、相关概述

备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，当前很多软件都提供了撤销(Undo)操作，其中就使用了备忘录模式。

1). 定义

• 备忘录模式(Memento Pattern)：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为Token。

---

备忘录模式的核心是备忘录类以及用于管理备忘录的负责人类的设计

2). 相关角色

1. Originator（原发器）：它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。
2. Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。
3. Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

需要防止原发器以外的其他对象访问备忘录，特别是不允许其他对象来修改备忘录。

3). 典型代码

1. 原发器类

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 原发器类
 */
@Data
@NoArgsConstructor
public class Originator {
    private String state;

    // 创建一个备忘录对象
    public Memento createMemento() {
        return new Memento(this);
    }

    // 根据备忘录对象恢复原发器状态
    public void restoreMemento(Memento m) {
        state = m.getState();
    }

}

原发器类是一个具体的业务类，它包含一些用于存储成员数据的属性

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 备忘录类，默认可见性，包内可见
 */
@Data
class Memento {
    private String state;

    public Memento(Originator o) {
        state = o.getState();
    }
}

通常提供了与原发器相对应的属性（可以是全部，也可以是部分）用于存储原发器的状态。在使用Java语言实现备忘录模式时，一般通过将Memento类与Originator类定义在同一个包(package)中来实现封装，在Java语言中可使用默认访问标识符来定义Memento类，即保证其包内可见。

3. 负责人类

/**
 * 负责人类
 */
@Data
public class Caretaker {
    private Memento memento;
}

Caretaker类中不应该直接调用Memento中的状态改变方法，它的作用仅仅用于存储/获取备忘录对象。

二、案例需求举例

1). 需求描述

象棋悔棋功能

---

以下实现进行了部分增强！

2). 代码实现

1. 原发器

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

/**
 * 原发器：象棋棋子类
 */
@Data
@ToString
@AllArgsConstructor
public class Chessman {
    private String label;
    private int x;
    private int y;

    // 保存状态
    public ChessmanMemento save() {
        return new ChessmanMemento(this.label, this.x, this.y);
    }

    // 恢复状态
    public void restore(ChessmanMemento memento) {
        this.label = memento.getLabel();
        this.x = memento.getX();
        this.y = memento.getY();
    }
}

2. 备忘录

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 备忘录：象棋棋子备忘录类
 */
@Data
@AllArgsConstructor
public class ChessmanMemento {
    private String label;
    private int x;
    private int y;
}

3. 负责人

import java.util.EmptyStackException;
import java.util.Stack;

/**
 * 负责人：象棋棋子备忘录管理类
 */
public class MementoCaretaker {

    // 保存当前使用的状态
    private ChessmanMemento currentChess;

    // 保存历史操作记录，以供撤销
    private Stack<ChessmanMemento> undoList = new Stack<>();

    // 保存撤销过的记录，用于反撤销
    private Stack<ChessmanMemento> redoList = new Stack<>();

    // 保存状态
    public void setMemento(ChessmanMemento memento) {
        this.currentChess = memento;
        this.undoList.push(this.currentChess);

        // 清除反撤销列表中保存的状态，因为开启了新的分支，旧分支在此业务中可以摒弃了
        if (redoList.size() != 0) {
            redoList.clear();
        }
    }

    // 悔一步棋
    public ChessmanMemento undo() {
        return this.undo(1);
    }

    // 悔多步棋
    public ChessmanMemento undo(int i) {

        if (i <= 0) {
            return this.currentChess;
        }

        try {
            // 这里设计为循环 i + 1次，因为负责人中当前状态与执行状态一致，所以得多操作一次
            for (int j = 0; j <= i; j++) {
                this.currentChess = undoList.pop();
                redoList.push(this.currentChess);
            }
        } catch (EmptyStackException e) {
            //e.printStackTrace();
        }

        return this.currentChess;
    }

    // 撤销悔棋
    public ChessmanMemento redo() {
        return this.redo(1);
    }

    // 撤销多步悔棋
    public ChessmanMemento redo(int i) {
        if (i <= 0) {
            return this.currentChess;
        }

        try {
            for (int j = 0; j <= i; j++) {
                this.currentChess = redoList.pop();
                undoList.push(this.currentChess);
            }
        } catch (EmptyStackException e) {
            //e.printStackTrace();
        }

        return this.currentChess;
    }
}

4. 测试代码

/**
 * 客户端测试代码
 * @author Liucheng
 * @since 2019-09-08
 */
public class Client {

    public static void main(String[] args) {

        // 棋子类
        Chessman chess = new Chessman("車", 1, 1);
        // 负责人
        MementoCaretaker taker = new MementoCaretaker();

        // 玩游戏
        chess.setX(2);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 继续玩儿游戏
        chess.setY(8);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 继续玩儿游戏
        chess.setY(3);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 继续玩儿游戏
        chess.setX(5);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 继续玩儿游戏
        chess.setX(7);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 继续玩儿游戏
        chess.setY(9);
        display(chess);
        // 保存状态
        taker.setMemento(chess.save());

        // 悔棋
        System.out.println("\n****悔一步棋****");
        chess.restore(taker.undo());
        display(chess);

        // 撤销悔棋
        System.out.println("\n****撤销悔一步棋****");
        chess.restore(taker.redo());
        display(chess);

        // 悔棋多步
        System.out.println("\n****悔三步棋****");
        chess.restore(taker.undo(3));
        display(chess);

        // 撤销悔棋多步
        System.out.println("\n****撤销悔二步棋****");
        chess.restore(taker.redo(2));
        display(chess);
    }

    public static void display(Chessman chess) {
        System.out.println("棋子" + chess.getLabel() + "当前位置:" + chess);
    }
}

5. 测试结果

棋子車当前位置:Chessman(label=車, x=2, y=1)
棋子車当前位置:Chessman(label=車, x=2, y=8)
棋子車当前位置:Chessman(label=車, x=2, y=3)
棋子車当前位置:Chessman(label=車, x=5, y=3)
棋子車当前位置:Chessman(label=車, x=7, y=3)
棋子車当前位置:Chessman(label=車, x=7, y=9)

****悔一步棋****
棋子車当前位置:Chessman(label=車, x=7, y=3)

****撤销悔一步棋****
棋子車当前位置:Chessman(label=車, x=7, y=9)

****悔三步棋****
棋子車当前位置:Chessman(label=車, x=2, y=3)

****撤销悔二步棋****
棋子車当前位置:Chessman(label=車, x=7, y=3)

三、总结

1). 阐述

1. 备忘录是一个很特殊的对象，只有原发器对它拥有控制的权力，负责人只负责管理，而其他类无法访问到备忘录，因此我们需要对备忘录进行封装。

2. 为了实现对备忘录对象的封装，需要对备忘录的调用进行控制，对于原发器而言，它可以调用备忘录的所有信息，允许原发器访问返回到先前状态所需的所有数据；对于负责人而言，只负责备忘录的保存并将备忘录传递给其他对象；对于其他对象而言，只需要从负责人处取出备忘录对象并将原发器对象的状态恢复，而无须关心备忘录的保存细节。理想的情况是只允许生成该备忘录的那个原发器访问备忘录的内部状态。

3. 在实际开发中，原发器与备忘录之间的关系是非常特殊的，它们要分享信息而不让其他类知道，实现的方法因编程语言的不同而有所差异，在C++中可以使用friend关键字，让原发器类和备忘录类成为友元类，互相之间可以访问对象的一些私有的属性；在Java语言中可以将原发器类和备忘录类放在一个包中，让它们之间满足默认的包内可见性，也可以将备忘录类作为原发器类的内部类，使得只有原发器才可以访问备忘录中的数据，其他对象都无法使用备忘录中的数据。

4. 备忘录模式在很多软件的使用过程中普遍存在，但是在应用软件开发中，它的使用频率并不太高，因为现在很多基于窗体和浏览器的应用软件并没有提供撤销操作。如果需要为软件提供撤销功能，备忘录模式无疑是一种很好的解决方案。在一些字处理软件、图像编辑软件、数据库管理系统等软件中备忘录模式都得到了很好的应用。

2). 优点

1. 它提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原。
2. 备忘录实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码所改动。备忘录保存了原发器的状态，采用列表、堆栈等集合来存储备忘录对象可以实现多次撤销操作。

3). 缺点

资源消耗过大，如果需要保存的原发器类的成员变量太多，就不可避免需要占用大量的存储空间，每保存一次对象的状态都需要消耗一定的系统资源。

4). 适用场景

1. 保存一个对象在某一个时刻的全部状态或部分状态，这样以后需要时它能够恢复到先前的状态，实现撤销操作。
2. 防止外界对象破坏一个对象历史状态的封装性，避免将对象历史状态的实现细节暴露给外界对象。