备忘录模式 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）为快照恢复

步骤解析：

1. 客户端程序对原发器originator进行状态设置
2. 客户端程序对原发器进行快照创建
3. 客户端程序对快照进行保存
4. 客户端程序获得快照
5. 客户端程序根据快照进行状态恢复

重构小结

重构的逻辑为：

• 借助于私有内部类实现了对外界的封闭
• 将负责人管理员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对象本身很占用资源，那么势必导致占用过多的内存空间，这都是一个个的对象

 

当你需要保存一个对象的瞬时的部分或者全部状态时，可以考虑使用备忘录模式

原文地址:备忘录模式 memento 快照模式 标记(token)模式 行为型 设计模式（二十二）