设计模式之备忘录模式

Posted 2021-08-15 二木成林

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式之备忘录模式相关的知识，希望对你有一定的参考价值。

概述

备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，很多软件都提供了撤销（Undo）操作，如 Word、记事本、Photoshop、IDEA等软件在编辑时按 Ctrl+Z 组合键时能撤销当前操作，使文档恢复到之前的状态；还有在浏览器中的后退键、数据库事务管理中的回滚操作、玩游戏时的中间结果存档功能、数据库与操作系统的备份操作、棋类游戏中的悔棋功能等都属于这类。

定义：又叫快照模式，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。

结构

备忘录模式的核心是设计备忘录类以及用于管理备忘录的管理者类。

备忘录模式的主要角色如下：

发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。
备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

备忘录有两个等效的接口：

窄接口：管理者(Caretaker)对象（和其他发起人对象之外的任何对象）看到的是备忘录的窄接口(narror Interface)，这个窄接口只允许他把备忘录对象传给其他的对象。

宽接口：与管理者看到的窄接口相反，发起人对象可以看到一个宽接口(wide Interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。

其UML类图如下：

各实现代码如下：

Memento.java

/**
 * @author lcl100
 * @create 2021-07-18 8:10
 * @desc 备忘录类，负责存储发起人的内部状态
 */
public class Memento {
    private String state;// 本例中的状态只是简单的字符串，可以有更复杂的状态

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

Caretasker.java

/**
 * @author lcl100
 * @create 2021-07-18 8:11
 * @desc 管理者，管理备忘录，不让发起人直接访问备忘录，而是通过管理者来操作
 */
public class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

Originator.java

/**
 * @author lcl100
 * @create 2021-07-18 8:13
 */
public class Originator {
    private String state;// 发起人的状态

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * 发起人创建备忘录
     *
     * @return 返回创建成功的备忘录对象
     */
    public Memento createMemento() {
        return new Memento(state);
    }

    /**
     * 恢复备忘录中的数据
     *
     * @param memento 存有某一时刻发起人状态的备忘录对象
     */
    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }
}

Test.java

/**
 * @author lcl100
 * @create 2021-07-18 8:16
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建发起人
        Originator originator = new Originator();
        // 创建管理者
        Caretaker caretaker = new Caretaker();

        // 设置发起人的状态
        originator.setState("S0");
        System.out.println("初始状态：" + originator.getState());// 打印设置后的状态
        caretaker.setMemento(originator.createMemento());// 发起人创建备忘录，并将备忘录保存到管理者中

        // 再次设置发起人新的状态
        originator.setState("S1");
        System.out.println("新的状态：" + originator.getState());// 打印设置后的状态

        // 恢复S0状态
        originator.restoreMemento(caretaker.getMemento());// 将保存在管理者那儿的备忘录恢复过来
        System.out.println("恢复状态：" + originator.getState());// 打印恢复后的状态
    }
}

撤销多次

注意：使用上述代码只能实现一次撤销，因为在负责人类中只定义一个备忘录对象来保存状态，后面保存的状态会将前一次保存的状态覆盖，但有时候用户需要撤销多步操作。如何实现多次撤销呢？一种多次撤销的解决方案，那就是在管理者类中定义一个集合来存储多个备忘录，每个备忘录负责保存一个历史状态，在撤销时可以对备忘录集合进行逆向遍历，回到一个指定的历史状态，而且还可以对备忘录集合进行正向遍历，实现重做(Redo)操作，即取消撤销，让对象状态得到恢复。

其UML类图如下：

各实现代码如下：

Memento.java

/**
 * @author lcl100
 * @create 2021-07-18 8:50
 * @desc 备忘录类，负责存储发起人的内部状态
 */
public class Memento {
    private String state;// 本例中的状态只是简单的字符串，可以有更复杂的状态

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

Caretaker.java

/**
 * @author lcl100
 * @create 2021-07-18 8:
 * @desc 管理者类
 */
public class Caretaker {
    private List<Memento> list = new ArrayList<>();

    /**
     * 设置备忘录，实际上是添加到list集合
     *
     * @param memento 待保存的备忘录
     */
    public void setMemento(Memento memento) {
        list.add(memento);
    }

    /**
     * 获取指定索引位置的备忘录，得到某个特定的状态
     *
     * @param i 指定索引
     * @return 返回得到的备忘录
     */
    public Memento getMemento(int i) {
        // 参数校验
        if (i < 0 || i >= list.size()) {
            return null;
        }
        return list.get(i);
    }
}

Originator.java

/**
 * @author lcl100
 * @create 2021-07-18 8:54
 */
public class Originator {
    private String state;// 发起人的状态

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * 发起人创建备忘录
     *
     * @return 返回创建成功的备忘录对象
     */
    public Memento createMemento() {
        return new Memento(state);
    }

    /**
     * 恢复备忘录中的数据
     *
     * @param memento 存有某一时刻发起人状态的备忘录对象
     */
    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }
}

Test.java

/**
 * @author lcl100
 * @create 2021-07-18 8:54
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建发起人
        Originator originator = new Originator();
        // 创建管理者
        Caretaker caretaker = new Caretaker();

        // 设置发起人的状态
        originator.setState("S0");
        System.out.println("初始状态：" + originator.getState());// 打印设置后的状态
        caretaker.setMemento(originator.createMemento());// 发起人创建备忘录，并将备忘录保存到管理者中

        // 再次设置发起人新的状态
        originator.setState("S1");
        System.out.println("新的状态：" + originator.getState());// 打印设置后的状态
        caretaker.setMemento(originator.createMemento());

        // 再次设置发起人新的状态
        originator.setState("S2");
        System.out.println("新的状态：" + originator.getState());// 打印设置后的状态
        caretaker.setMemento(originator.createMemento());

        // 恢复S1状态
        originator.restoreMemento(caretaker.getMemento(1));// 将保存在管理者那儿的备忘录恢复过来，恢复S1状态
        System.out.println("恢复状态：" + originator.getState());// 打印恢复后的状态
    }
}

白箱与黑箱备忘录模式

白箱备忘录模式就是备忘录角色对任何对象都提供一个接口，即宽接口，备忘录角色的内部所存储的状态就对所有对象公开。而上面的两个例子都是白箱备忘录模式。

白箱备忘录模式是破坏封装性的。但是通过程序员自律，同样可以在一定程度上实现模式的大部分用意。

黑箱备忘录模式就是备忘录角色对发起人对象提供一个宽接口，而为其他对象提供一个窄接口。在Java语言中，实现双重接口的办法就是将备忘录类设计成发起人类的内部成员类。

具体方法就是将备忘录类Memento设为发起人角色Originator的内部类，而将Memento对象封装在Originator里面，在外面提供一个标识接口MementoInterface给管理者Caretaker及其他对象适用。这样Originattor类看到的是备忘录Memento的所有接口，而管理者Caretaker及其他对象看到的仅仅是标识接口MementoInterface所暴露出来的接口，从而维护了封装性。其UML类图如下：

各实现代码如下：

MementoInterface.java

/**
 * @author lcl100
 * @create 2021-07-18 9:20
 * @desc 窄接口MementoInterface，这是一个标识接口，因此没有定义出任何的方法
 */
public interface MementoInterface {

}

Originator.java

/**
 * @author lcl100
 * @create 2021-07-18 9:23
 * @desc 定义发起人类Originator，并在内部定义备忘录内部类Memento（该内部类设置为私有的）
 */
public class Originator {
    private String state;// 发起人的状态

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * 发起人创建备忘录
     *
     * @return 返回创建成功的备忘录对象
     */
    public MementoInterface createMemento() {
        return new Memento(state);
    }

    /**
     * 恢复备忘录中的数据
     *
     * @param memento 存有某一时刻发起人状态的备忘录对象
     */
    public void restoreMemento(MementoInterface memento) {
        Memento m=(Memento)memento;
        this.setState(m.getState());
    }


    // 内部类
    private class Memento implements MementoInterface{
        private String state;// 本例中的状态只是简单的字符串，可以有更复杂的状态

        public Memento(String state) {
            this.state = state;
        }

        public String getState() {
            return state;
        }

        public void setState(String state) {
            this.state = state;
        }
    }
}

Caretaker.java

/**
 * @author lcl100
 * @create 2021-07-18 9:25
 * @desc 负责人角色类Caretaker能够得到的备忘录对象是以MementoInterface为接口的，由于这个接口仅仅是一个标识接口，因此负责人角色不可能改变这个备忘录对象的内容
 */
public class Caretaker {
    private MementoInterface memento;

    public MementoInterface getMemento() {
        return memento;
    }

    public void setMemento(MementoInterface memento) {
        this.memento = memento;
    }
}

Test.java

/**
 * @author lcl100
 * @create 2021-07-18 8:16
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建发起人
        Originator originator = new Originator();
        // 创建管理者
        Caretaker caretaker = new Caretaker();

        // 设置发起人的状态
        originator.setState("S0");
        System.out.println("初始状态：" + originator.getState());// 打印设置后的状态
        caretaker.setMemento(originator.createMemento());// 发起人创建备忘录，并将备忘录保存到管理者中

        // 再次设置发起人新的状态
        originator.setState("S1");
        System.out.println("新的状态：" + originator.getState());// 打印设置后的状态

        // 恢复S0状态
        originator.restoreMemento(caretaker.getMemento());// 将保存在管理者那儿的备忘录恢复过来
        System.out.println("恢复状态：" + originator.getState());// 打印恢复后的状态
    }
}

优缺点

备忘录模式是一种对象行为型模式，其主要优点如下。

提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。
实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能够访问这些状态信息。
简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。

其主要缺点是：

资源消耗大。如果要保存的内部状态信息过多或者特别频繁，将会占用比较大的内存资源。

适用场景：

需要保存与恢复数据的场景，如玩游戏时的中间结果的存档功能。
需要提供一个可回滚操作的场景，如 Word、记事本、Photoshop，idea等软件在编辑时按 Ctrl+Z 组合键，还有数据库中事务操作。