备忘录Memento快照标记Token模式 行为型设计模式（二十二）
备忘录模式 Memento!(data/attachment/forum/202208/02/154312juvzesisbozi48si.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
**沿着脚印，走过你来时的路，回到原点。**
苦海翻起爱恨
在世间难逃避命运
相亲竟不可接近
或我应该相信是缘份
一首《一生所爱》触动了多少人的心弦，一段五百年都没有结果的爱情，让多少人潸然泪下。
有人说：当你真正看懂了《大话西游》，你就真的懂了爱情；那么，当你听懂了《一生所爱》，你就真的懂了什么是哀伤和无奈。
《大话西游》是不可超越的经典，在《月光宝盒》中，至尊宝为了救白晶晶，**使用月光宝盒使时光倒流**，几次后产生故障，竟将其带回五百年前，这时紫霞仙子（朱茵饰）向她走来......
百度百科中关于词条“VMware快照”的描述
磁盘“快照”是虚拟机磁盘文件（VMDK）在某个点即时的复本。
系统崩溃或系统异常，你可以通过使用**恢复到快照来保持磁盘文件系统和系统存储**。
当升级应用和服务器及给它们打补丁的时候，快照是救世主。VMware快照是VMware Workstation里的一个特色功能。
!(data/attachment/forum/202208/02/154327gpgt6h9t33mquqoq.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
“脚印”记录了我们来时的路，所以我们可以原路返回；
“月光宝盒”记录了时间的状态，所以至尊宝可以时光穿梭；
“VMware快照”记录了虚拟机磁盘文件（VMDK）在某个点的状态，所以可以通过快照进行系统恢复；
**以上，他们都记录了状态，进而可以恢复到原来的状态**
### 意图
**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。**
**这样以后就可以将该对象恢复到原先保存的状态。**
**别名：快照模式或者token标记模式**
在程序开发过程中，有时可能需要记录对象的状态，以便允许用户取消不确定的操作或者从错误恢复过来
**对象的某个瞬时状态，叫做快照**（如同你去拍证件照，立等可取，快速的拍照，俗称快照）
**每一个快照，通常叫做一个检查点**。
**想要实现快照和撤销恢复机制，就必须将对象的状态保存起来。**
**这就是备忘录模式的初衷**。
面向对象的三大特征之一就是封装，对象往往封装了他的状态信息，使之与外部的对象隔离
这部分信息通常都是私有的private，不能被外部对象访问，也就是说不能在外部进行保存
如果暴露内部属性比如设置为public，可以外部保存，但是这又违反了封装的原则。
换句话说，封装起来，外部就不能直接访问，但是我们又需要将他的状态保存在外部
而且还不想破坏封装性，也不想暴露内部属性。
也就是**如何将对象的状态保存在外部，但是外部却仍旧不知道对象的属性细节**？
这个问题类似于：你想把你的一堆私人物品找个地方保存，但是你又不想别人看到你里面的东西怎么办？
最简单的方式就是借助于行李箱
大家都坐过火车，在车站都有箱包寄存处
我们把所有的物品锁到行李箱中，行李箱寄存起来，管理员负责管理我们的行李箱，他并不知道我们箱子里面装的到底是什么
当我们回来取箱子时，管理员将箱子交还给我们，他自始至终都不知道箱子里是什么
在程序中，我们应该如何解决这个问题呢？也就是又能外部保存，又不破坏封装？
备忘录模式就是解决这种场景问题的，通过引入备忘录角色Memento和控制外界对他的访问来解决。
### 结构
!(data/attachment/forum/202208/02/154354m34f62542mf3z2b8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
**原发器角色Originator**
也叫做发起者，原发器是需要被保存状态的角色，也就是我们的业务逻辑对象
他创建备忘录Memento对象，也就是创建快照，并且负责借助于备忘录对象Memento恢复状态
**备忘录角色Memento**
负责记录Originator的部分或者全部状态，也就是拥有Originator的部分或者全部属性
备忘录角色的设计必然要参考Originator
备忘录角色应该仅仅允许Originator对其进行修改访问，其他包括CareTaker只能够对备忘录进行传递
备忘录角色就是前文的“行李箱”
**管理员角色CareTaker**
负责管理保存备忘录
上面说到备忘录模式的解决问题思路“**引入备忘录角色Memento和控制外界对他的访问来解决**”
具体为：
* 备忘录模式通过引入备忘录Memento记录对象的内部状态
* 引入管理员CareTaker对备忘录进行管理
* 控制访问--原发器Originator与备忘录对象进行交互，其他所有地方都只是获取传递，不更改设置Memento的状态
也就是**通过备忘录对象对原始对象需要保存的内部状态进行封装**
而且，控制对他的访问，外人不能访问内部
这样借助于备忘录对象这个中间层就实现了“**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态**”
**对于备忘录对象访问的控制是必须的**，如果外界可以随意访问变更备忘录对象
某种程度上来说相当于可以更改原始对象的私有属性了
这是不安全的
**备忘录模式将“内部状态”与“外界保存”进行解耦，通过中间层备忘录对象来连接。**
### 代码示例
#### 一个简单的快照实现
有一个业务逻辑类Originator，快照主要是对他的状态，也就是内部state属性，进行备份
快照信息保存在备忘录Memento中
通过管理员CareTaker进行保管
```java
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();
}
}
```
```java
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;
}
}
```
```java
package memento.simple;
/**
* 管理员类,内部拥有一个memento,可以设置和获取这个属性
*/
public class CareTaker {
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
```
```java
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());
}
}
```
!(data/attachment/forum/202208/02/154452gadc5j5gcnnnze4e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
上面的示例中，备忘录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对象
!(data/attachment/forum/202208/02/154510o23a1cm9xp9cme0u.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
这样在原来的基础上，将限制增强了，只要是Close类型，那么就不能修改Originator了
不过显然，Open接口也不是私有的，外界仍旧可以使用，所以只是比原来稍微强化一点
并不能彻底解决
#### 内部类方式重构
在java中，可以借助**内部类**的形式
因为内部类与外部类是友好的
另外与**Close接口**结合使用，实现对外界的关闭
**标记接口**，外界看到的始终是标记接口，无方法可用
```java
package memento;
public interface MementoInterface {
}
```
**原发器**，将Memento放置在内部，对外界仅仅返回标记接口
只有内部才拥有真正的Memento类型
```java
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
```java
package memento;
/**
* 管理员类,内部拥有一个 MementoInterface,可以设置和获取这个属性
*/
public class CareTaker {
private MementoInterface memento;
public MementoInterface getMemento() {
return memento;
}
public void setMemento(MementoInterface memento) {
this.memento = memento;
}
}
```
!(data/attachment/forum/202208/02/154556j3ie49k5p13x4kze.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
!(data/attachment/forum/202208/02/154613tv7utu7k874989uk.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
重构后的打印结果如上图所示与原来一致，但是外界却不能修改备忘录对象，备忘录仅仅对原发器开放
!(data/attachment/forum/202208/02/154626p4d9mv4maw4pzlwu.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
上图为重构后的结构
Memento作为Originator的内部类，有外部类的引用
隐藏了Open接口，或者说Memento自身也代表了Open接口角色，提供方法可以给外部类Originator使用
CareTaker通过MementoInterface交互，无法访问Memento内部属性
客户端访问Originator和CareTaker，借助于CareTaker管理CareTaker创建的快照
#### 时序图
!(data/attachment/forum/202208/02/154647w03yvvd8tk87dtdx.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
时序图上半部分（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这就实现了客户端功能的封装
```java
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角色
伪代码:
```java
public static void main(String[] args) {
Memento memento = originator.createMemento();
originator.recovery(originator.recovery();
}
```
本文作者:程序员潇然 疯狂的字节X https://crazybytex.com/
**Originator与Memento合并**
备忘录模式的根本在于状态的保存，模式的结构是一种通用的解决方案
Memento对象是对于Originator内部部分或者全部状态的一个封装
如果只是保存对象的状态，也可以借助于**原型模式**进行替代
也就是说使用另外一个新的Originator对象保存当前Originator对象的状态，这与白盒方式的备忘录模式效果一样
### 与命令模式的联系
命令模式中将“方法调用”这种命令行为或者说请求 进一步的抽象
封装为一个命令对象，从而可以达到对请求记录的功能，进而可以实现撤销操作。
备忘录模式也是为了记录对象的内部状态，为实现撤销操作做基础工作。
命令模式侧重于请求历史的日志记录，能够记录操作的轨迹，然后调用命令接收者的撤销方法
而撤销方法基本上需要对象的内部状态
备忘录模式则是记录对象的状态变化
一个是宏观一个是微观
所以说，**备忘录模式与命令模式不是可替代关系，而是可以相互配合的好基友**
命令模式记录操作历史，备忘录模式记录对象的状态，一起配合实现撤销的操作。
### 总结
备忘录模式，模式如其名，就是记录状态信息。
**备忘录模式引入备忘录角色将对象的“内部状态”与“外部保存”进行解耦**
**通过对备忘录角色的访问限制，达到备忘录对原发器Originator开放，对外界关闭的效果**。
备忘录模式的重点在于对于Memento的访问控制---对Originator开放，对外界关闭
也就是通常所谓的**双接口支持**，就是双重标准嘛
这**也是一种设计思维**，**为了系统安全，提供一个标记接口给外部访问**。能够保障系统的安全。
通过对状态的记录，提供了状态恢复的实现机制。
每个备忘录对象都是Originator对象的一个瞬时状态，**通过对状态变化轨迹的记录，可以实现多次状态轨迹的还原**。
而且，复杂场景，还可以与命令模式结合使用。
缺点也是明显的，对于Originator对象的每一个瞬时状态都使用Memento对象进行保存
如果Originator对象本身很占用资源，那么势必导致占用过多的内存空间，这都是一个个的对象
当你需要保存一个对象的瞬时的部分或者全部状态时，可以考虑使用备忘录模式
!(data/attachment/forum/202206/16/141330jha7st9soow8772i.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "common_log.png")
`转载务必注明出处：程序员潇然，疯狂的字节X，https://crazybytex.com/thread-121-1-1.html `
页:
[1]