备忘录模式 Memento 快照模式标记Token模式行为型设计模式（二十二）

备忘录模式 Memento 沿着脚印，走过你来时的路，回到原点。 苦海翻起爱恨在世间难逃避命运相亲竟不可接近或我应该相信是缘份一首《一生所爱》触动了多少人的心弦，一段五百年都没有结果的爱情，让多少人潸然泪下。有人说：当你真正看懂了《大话西游》，你就真的懂了爱情；那么，当你听懂了《一生所爱》，你就真的懂了什么是哀伤和无奈。《大话西游》是不可超越的经典，在《月光宝盒》中，至尊宝为了救白晶晶，使用月光宝盒使时光倒流，几次后产生故障，竟将其带回五百年前，这时紫霞仙子（朱茵饰）向她走来...... 百度百科中关于词条“VMware快照”的描述磁盘“快照”是虚拟机磁盘文件（VMDK）在某个点即时的复本。系统崩溃或系统异常，你可以通过使用恢复到快照来保持磁盘文件系统和系统存储。当升级应用和服务器及给它们打补丁的时候，快照是救世主。VMware快照是VMware Workstation里的一个特色功能。

“脚印”记录了我们来时的路，所以我们可以原路返回； “月光宝盒”记录了时间的状态，所以至尊宝可以时光穿梭； “VMware快照”记录了虚拟机磁盘文件（VMDK）在某个点的状态，所以可以通过快照进行系统恢复； 以上，他们都记录了状态，进而可以恢复到原来的状态

意图

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 这样以后就可以将该对象恢复到原先保存的状态。 别名：快照模式或者token标记模式 在程序开发过程中，有时可能需要记录对象的状态，以便允许用户取消不确定的操作或者从错误恢复过来 对象的某个瞬时状态，叫做快照（如同你去拍证件照，立等可取，快速的拍照，俗称快照） 每一个快照，通常叫做一个检查点。 想要实现快照和撤销恢复机制，就必须将对象的状态保存起来。 这就是备忘录模式的初衷。面向对象的三大特征之一就是封装，对象往往封装了他的状态信息，使之与外部的对象隔离这部分信息通常都是私有的private，不能被外部对象访问，也就是说不能在外部进行保存如果暴露内部属性比如设置为public，可以外部保存，但是这又违反了封装的原则。换句话说，封装起来，外部就不能直接访问，但是我们又需要将他的状态保存在外部而且还不想破坏封装性，也不想暴露内部属性。也就是如何将对象的状态保存在外部，但是外部却仍旧不知道对象的属性细节？这个问题类似于：你想把你的一堆私人物品找个地方保存，但是你又不想别人看到你里面的东西怎么办？最简单的方式就是借助于行李箱大家都坐过火车，在车站都有箱包寄存处我们把所有的物品锁到行李箱中，行李箱寄存起来，管理员负责管理我们的行李箱，他并不知道我们箱子里面装的到底是什么当我们回来取箱子时，管理员将箱子交还给我们，他自始至终都不知道箱子里是什么在程序中，我们应该如何解决这个问题呢？也就是又能外部保存，又不破坏封装？备忘录模式就是解决这种场景问题的，通过引入备忘录角色Memento和控制外界对他的访问来解决。

结构

原发器角色Originator 也叫做发起者，原发器是需要被保存状态的角色，也就是我们的业务逻辑对象他创建备忘录Memento对象，也就是创建快照，并且负责借助于备忘录对象Memento恢复状态 备忘录角色Memento 负责记录Originator的部分或者全部状态，也就是拥有Originator的部分或者全部属性备忘录角色的设计必然要参考Originator 备忘录角色应该仅仅允许Originator对其进行修改访问，其他包括CareTaker只能够对备忘录进行传递备忘录角色就是前文的“行李箱” 管理员角色CareTaker 负责管理保存备忘录上面说到备忘录模式的解决问题思路“引入备忘录角色Memento和控制外界对他的访问来解决” 具体为：

备忘录模式通过引入备忘录Memento记录对象的内部状态
引入管理员CareTaker对备忘录进行管理
控制访问--原发器Originator与备忘录对象进行交互，其他所有地方都只是获取传递，不更改设置Memento的状态

也就是通过备忘录对象对原始对象需要保存的内部状态进行封装 而且，控制对他的访问，外人不能访问内部这样借助于备忘录对象这个中间层就实现了“在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态” 对于备忘录对象访问的控制是必须的，如果外界可以随意访问变更备忘录对象某种程度上来说相当于可以更改原始对象的私有属性了这是不安全的 备忘录模式将“内部状态”与“外界保存”进行解耦，通过中间层备忘录对象来连接。

代码示例

一个简单的快照实现

有一个业务逻辑类Originator，快照主要是对他的状态，也就是内部state属性，进行备份
快照信息保存在备忘录Memento中
通过管理员CareTaker进行保管

package memento.simple;
/**
* 业务逻辑类,也就是我们需要备份的对象
* 内部拥有state属性,用来表示快照需要保存的状态数据
*/
public class Originator {
    private Integer state;
    /**
    * 创建快照备份
    * @return
    */
    public Memento createMemento() {
        return new Memento(state);
    }
    /**
    * 恢复快照
    * @param memento
    */
    public void recovery(Memento memento) {
        state = memento.getState();
    }
     
    public Integer getState() {
        return state;
    }
     
    public void setState(Integer state) {
        this.state = state;
    }
     
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Originator{");
        sb.append("state=").append(state);
        sb.append('}');
        return sb.toString();
    }
}

package memento.simple;
/**
* 备忘录类用来保存业务逻辑对象的状态(原发器)
* 备忘录类的属性要参考原发器的设计,确定需要保存哪些数据信息
* 此处我们以state为演示
* 备忘录类提供了getter和setter方法
*/
public class Memento {
    private Integer state;
    Memento(Integer state) {
        this.state = state;
    }
     
    public Integer getState() {
        return state;
    }
     
    public void setState(Integer state) {
        this.state = state;
    }
}

package memento.simple;
/**
* 管理员类,内部拥有一个memento,可以设置和获取这个属性
*/
public class CareTaker {
 
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
     
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

package memento.simple;
public class Test {
 
public static void main(String[] args) {
 
    //创建业务逻辑对象,设置状态信息
    Originator originator = new Originator();
    originator.setState(2);
     
    //快照
    Memento memento = originator.createMemento();
    CareTaker careTaker = new CareTaker();
    careTaker.setMemento(memento);
     
    System.out.println("初始时状态: " + originator.toString());
     
    originator.setState(3);
    System.out.println("更新状态后: " + originator.toString());
     
    originator.setState(8);
    System.out.println("更新状态后: " + originator.toString());
     
    originator.setState(6);
    System.out.println("更新状态后: " + originator.toString());
     
    originator.recovery(careTaker.getMemento());
    System.out.println("恢复状态后: " + originator.toString());
    }
}

上面的示例中，备忘录Memento对象封装保存原发器角色Originator的状态，管理员CareTaker对备忘录进行管理 Memento内部的属性state，尽管我们设置了公有的访问器 getter和setter，但是CareTaker以及外界并没有对Memento进行访问我们是借助于代码逻辑实现了：

Memento备忘录对来自Originator的修改开放（比如上面的Originator可以创建Memento）
Memento备忘录对来自CareTaker的修改开放（上面示例中，仅仅传递Memento，不曾访问内部细节）

这种模式又被称为白盒模式，因为Memento备忘录大家都看得到，而且都能够对她进行设置处理我们是借助于“大家写代码的时候都不要访问修改Memento备忘录对象的属性”这一要求完成的可能一不留神，某个人的代码中就修改了Memento备忘录对象。说白了，这种对原发器开放，对外界关闭的限制不是强制的，容易出问题。 怎么才能够强制将备忘录类仅仅对原发器开放，对外界关闭？ 我们可以定义两个接口，Open Close用于描述开放和关闭（close接口意为对外界封闭的接口）所有的对Memento的操作方法，全部定义在Open中，Close不定义任何方法，也就是标记接口给原发器Originator使用接口Open，外部所有的地方使用Close类型这样所有使用Close的地方，都不能够修改Memento对象这样在原来的基础上，将限制增强了，只要是Close类型，那么就不能修改Originator了不过显然，Open接口也不是私有的，外界仍旧可以使用，所以只是比原来稍微强化一点并不能彻底解决

内部类方式重构

在java中，可以借助内部类的形式因为内部类与外部类是友好的另外与Close接口结合使用，实现对外界的关闭 标记接口，外界看到的始终是标记接口，无方法可用

package memento;
public interface MementoInterface {
}

原发器，将Memento放置在内部，对外界仅仅返回标记接口只有内部才拥有真正的Memento类型

package memento;
/**
* 业务逻辑类,也就是我们需要备份的对象 内部拥有state属性,用来表示快照需要保存的状态数据
*/
public class Originator {
    private Integer state;
    /**
    * 创建快照备份返回标记接口,以使外界不能操作备忘录
    */
    public Memento createMemento() {
        return new Memento(state);
    }
    /**
    * 恢复快照,接受MementoInterface类型参数 使用时强转为内部类Memento
    */
    public void recovery(MementoInterface memento) {
        state = ((Memento) memento).getState();
    }
    public Integer getState() {
        return state;
    }
    public void setState(Integer state) {
        this.state = state;
    }
    /**
    * 私有内部类,实现MementoInterface接口,标记接口 用以外界交互,达到对外界close的效果
    */
    private class Memento implements MementoInterface {
            private Integer state;
         
        Memento(Integer state) {
            this.state = state;
        }
         
        public Integer getState() {
            return state;
        }
         
        public void setState(Integer state) {
            this.state = state;
        }
    }
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Originator{");
        sb.append("state=").append(state);
        sb.append('}');
        return sb.toString();
    }
}

外界仅仅接触到MementoInterface类型 CareTaker维护memento

package memento;
/**
* 管理员类,内部拥有一个 MementoInterface,可以设置和获取这个属性
*/
public class CareTaker {
    private MementoInterface memento;
    public MementoInterface getMemento() {
        return memento;
    }
    public void setMemento(MementoInterface memento) {
        this.memento = memento;
    }
}

重构后的打印结果如上图所示与原来一致，但是外界却不能修改备忘录对象，备忘录仅仅对原发器开放上图为重构后的结构 Memento作为Originator的内部类，有外部类的引用隐藏了Open接口，或者说Memento自身也代表了Open接口角色，提供方法可以给外部类Originator使用 CareTaker通过MementoInterface交互，无法访问Memento内部属性客户端访问Originator和CareTaker，借助于CareTaker管理CareTaker创建的快照

时序图

时序图上半部分（1,2,3）为快照保存，下半部分（4,5）为快照恢复步骤解析：

客户端程序对原发器Originator进行状态设置
客户端程序对原发器进行快照创建
客户端程序对快照进行保存
客户端程序获得快照
客户端程序根据快照进行状态恢复

重构小结

重构的逻辑为：

借助于私有内部类实现了对外界的封闭
将负责人管理员CareTaker与Memento进行解耦，通过抽象MementoInterface进行连接

也就是使用MementoInterface作为外界与Memento访问的中间层更加合理的实现了“在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态” 多版本快照 上面的示例中，CareTaker仅仅定义了一个内部属性 private MementoInterface memento; 也就是只能保存一种状态，实际情况下显然不会如此简单，所以可以借助于集合框架对快照进行管理比如使用HashMap（String,MementoInterface）进行快照版本控制，key可以为版本号

形式变换

CareTaker管理功能的增强 在上面重构后的示例中，客户端对Originator进行操作，并且负责快照的创建以及保存以及恢复快照时的快照读取也就是说客户端程序自身协调Originator与CareTaker，CareTaker仅仅负责快照的保存可以考虑将客户端程序的功能封装到CareTaker中 其余部分不变，仅仅调整CareTaker 内部新增了属性Originator，通过构造方法注入新增了创建快照和恢复的方法，底层依赖Originator 这就实现了客户端功能的封装

package memento.refactor1;
/**
* 管理员类,内部拥有一个 MementoInterface,可以设置和获取这个属性
*/
public class CareTaker {
 
    private MementoInterface memento;
    private Originator originator;
     
    CareTaker(Originator originator) {
    this.originator = originator;
    }
     
    /**
    * 创建快照,借助于内部的Originator
    */
    public MementoInterface createMemento() {
        return originator.createMemento();
    }
     
    /**
    * 恢复快照,借助于内部的Originator
    */
    public void recovery(MementoInterface memento) {
        originator.recovery(memento);
    }
    public MementoInterface getMemento() {
        return memento;
    }
    public void setMemento(MementoInterface memento) {
        this.memento = memento;
    }
}

变种形式实现了CareTaker对Originator的完全管理，而不仅仅是保存快照 简化的CareTaker careTaker用于保存快照或者可以变形为大保姆，不仅仅保存快照，也用于Originator快照的创建与恢复在有些场景下，也可以省略CareTaker 在我们上面的示例测试主函数中，一边创建了快照，很快下面就用到了快照进行恢复这种场景，显然没有必要专门的安排管理员，可以省略CareTaker角色伪代码:

public static void main(String[] args) {
Memento memento = originator.createMemento();
originator.recovery(originator.recovery();
}

Originator与Memento合并 备忘录模式的根本在于状态的保存，模式的结构是一种通用的解决方案 Memento对象是对于Originator内部部分或者全部状态的一个封装如果只是保存对象的状态，也可以借助于原型模式进行替代也就是说使用另外一个新的Originator对象保存当前Originator对象的状态，这与白盒方式的备忘录模式效果一样

与命令模式的联系

命令模式中将“方法调用”这种命令行为或者说请求进一步的抽象封装为一个命令对象，从而可以达到对请求记录的功能，进而可以实现撤销操作。备忘录模式也是为了记录对象的内部状态，为实现撤销操作做基础工作。命令模式侧重于请求历史的日志记录，能够记录操作的轨迹，然后调用命令接收者的撤销方法而撤销方法基本上需要对象的内部状态备忘录模式则是记录对象的状态变化一个是宏观一个是微观所以说，备忘录模式与命令模式不是可替代关系，而是可以相互配合的好基友 命令模式记录操作历史，备忘录模式记录对象的状态，一起配合实现撤销的操作。

总结

备忘录模式，模式如其名，就是记录状态信息。 备忘录模式引入备忘录角色将对象的“内部状态”与“外部保存”进行解耦 通过对备忘录角色的访问限制，达到备忘录对原发器Originator开放，对外界关闭的效果。备忘录模式的重点在于对于Memento的访问控制---对Originator开放，对外界关闭也就是通常所谓的双接口支持，就是双重标准嘛这也是一种设计思维，为了系统安全，提供一个标记接口给外部访问。能够保障系统的安全。通过对状态的记录，提供了状态恢复的实现机制。每个备忘录对象都是Originator对象的一个瞬时状态，通过对状态变化轨迹的记录，可以实现多次状态轨迹的还原。而且，复杂场景，还可以与命令模式结合使用。缺点也是明显的，对于Originator对象的每一个瞬时状态都使用Memento对象进行保存如果Originator对象本身很占用资源，那么势必导致占用过多的内存空间，这都是一个个的对象当你需要保存一个对象的瞬时的部分或者全部状态时，可以考虑使用备忘录模式原文地址:

02.设计模式

备忘录模式 Memento 快照模式标记Token模式行为型设计模式（二十二）

意图

结构

代码示例

一个简单的快照实现

内部类方式重构

时序图

重构小结

形式变换

与命令模式的联系

总结

相关

标签

备忘录模式 Memento 快照模式 标记Token模式 行为型 设计模式（二十二）

意图

结构

代码示例

一个简单的快照实现

内部类方式重构

时序图

重构小结

形式变换

与命令模式的联系

总结

相关

标签

备忘录模式 Memento 快照模式标记Token模式行为型设计模式（二十二）