备忘录模式 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进行保管
快照信息保存在备忘录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对象本身很占用资源，那么势必导致占用过多的内存空间，这都是一个个的对象
当你需要保存一个对象的瞬时的部分或者全部状态时，可以考虑使用备忘录模式