「补课」进行时：设计模式(17)——备忘录模式
1. 前文汇总
2. 从版本控制开始
相信每个程序猿，每天工作都会使用版本控制工具，不管是微软提供的 vss 还是 tfs ，又或者是开源的 svn 或者 git ，每天下班前，总归会使用版本控制工具提交一版代码。
版本管理工具是让我们在代码出问题的时候，可以方便的获取到之前的版本进行版本回退，尤其是在项目发布投运的时候，当出现问题的时候直接获取上一个版本进行回滚操作。
在这个操作中间，最重要的就是保存之前的状态，那么如何保存之前的状态？
操作很简单，我们可以定义一个中间变量，保留这个原始状态。
先定义一个版本管理 Git 类：
public class Git {
private String state;
// 版本发生改变，现在是 version2
public void changeState() {
this.state = "version2";
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
然后是一个场景 Client 类：
public class Client {
public static void main(String[] args) {
Git git = new Git();
// 初始化版本
git.setState("version1");
System.out.println("当前的版本信息：");
System.out.println(git.getState());
// 记录下当前的状态
Git backup = new Git();
backup.setState(git.getState());
// 提交一个版本，版本进行改变
git.changeState();
System.out.println("提交一个版本后的版本信息：");
System.out.println(git.getState());
// 回退一个版本，版本信息回滚
git.setState(backup.getState());
System.out.println("回退一个版本后的版本信息：");
System.out.println(git.getState());
}
}
执行结果：
当前的版本信息：
version1
提交一个版本后的版本信息：
version2
回退一个版本后的版本信息：
version1
程序运行正确，输出结果也是我们期望的，但是结果正确并不表示程序是合适的。
在场景类 Client 类中，这个是高层模块，现在却在高层模块中做了中间临时变量 backup 的状态的保持，为什么一个状态的保存和恢复要让高层模块来负责呢？
这个中间临时变量 backup 应该是 Git 类的职责，而不是让一个高层次的模块来进行定义。
我们新建一个 Memento 类，用作负责状态的保存和备份。
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;
}
}
新建一个 Memento ，用构造函数来传递状态 state ，修改上面的 Git 类，新增两个方法 createMemento() 和 restoreMemento()，用来创建备忘录以及恢复一个备忘录。
public class Git {
private String state;
// 版本发生改变，现在是 version2
public void changeState() {
this.state = "version2";
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
// 创建一个备忘录
public Memento createMemento(String state) {
return new Memento(state);
}
// 恢复一个备忘录
public void restoreMemento(Memento memento) {
this.setState(memento.getState());
}
}
修改后的场景类：
public class Client {
public static void main(String[] args) {
Git git = new Git();
// 初始化版本
git.setState("version1");
System.out.println("当前的版本信息：");
System.out.println(git.getState());
// 记录下当前的状态
Memento mem = git.createMemento(git.getState());
// 提交一个版本，版本进行改变
git.changeState();
System.out.println("提交一个版本后的版本信息：");
System.out.println(git.getState());
// 项目发布失败，回滚状态
git.restoreMemento(mem);
System.out.println("回退一个版本后的版本信息：");
System.out.println(git.getState());
}
}
运行结果和之前的案例保持一致，那么这就结束了么，当然没有，虽然我们在 Client 中不再需要重复定义 Git 类了，但是这是对迪米特法则的一个亵渎，它告诉我们只和朋友类通信，那这个备忘录对象是我们必须要通信的朋友类吗？对高层模块来说，它最希望要做的就是创建一个备份点，然后在需要的时候再恢复到这个备份点就成了，它不用关心到底有没有备忘录这个类。
那我们可以对这个备忘录的类再做一下包装，创建一个管理类，专门用作管理这个备忘录：
public class Caretaker {
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
非常简单纯粹的一个 JavaBean ，甭管它多简单，只要有用就成，我们来看场景类如何调用：
public class Client {
public static void main(String[] args) {
Git git = new Git();
// 创建一个备忘录管理者
Caretaker caretaker = new Caretaker();
// 初始化版本
git.setState("version1");
System.out.println("当前的版本信息：");
System.out.println(git.getState());
// 记录下当前的状态
caretaker.setMemento(git.createMemento(git.getState()));
// 提交一个版本，版本进行改变
git.changeState();
System.out.println("提交一个版本后的版本信息：");
System.out.println(git.getState());
// 项目发布失败，回滚状态
git.restoreMemento(caretaker.getMemento());
System.out.println("回退一个版本后的版本信息：");
System.out.println(git.getState());
}
}
现在这个备份者就类似于一个备份的仓库管理员，创建一个丢进去，需要的时候再拿出来。这就是备忘录模式。
3. 备忘录模式
3.1 定义
备忘录模式（Memento Pattern）提供了一种弥补真实世界缺陷的方法，让“后悔药”在程序的世界中真实可行，其定义如下：
Without violating encapsulation,capture and externalize an object's internalstate so that the object can be restored to this state later.（在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。）
3.2 通用类图
Originator 发起人角色：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。 Memento 备忘录角色：负责存储 Originator 发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。 Caretaker 备忘录管理员角色：对备忘录进行管理、保存和提供备忘录。
3.3 通用代码
发起人：
public class Originator {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
// 创建一个备忘录
public Memento createMemento() {
return new Memento(this.state);
}
// 恢复一个备忘录
public void restoreMemento(Memento memento) {
this.setState(memento.getState());
}
}
备忘录：
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;
}
}
备忘录管理员：
public class Caretaker {
// 备忘录对象
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
场景类：
public class Client {
public static void main(String[] args) {
// 定义发起人
Originator originator = new Originator();
// 定义备忘录管理员
Caretaker caretaker = new Caretaker();
// 创建一个备忘录
caretaker.setMemento(originator.createMemento());
// 恢复一个备忘录
originator.restoreMemento(caretaker.getMemento());
}
}
4. clone 方式的备忘录
我们可以通过复制的方式产生一个对象的内部状态，这是一个很好的办法，发起人角色只要实现 Cloneable 就成，比较简单：
public class Originator implements Cloneable {
// 内部状态
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
private Originator backup;
// 创建一个备忘录
public void createMemento() {
this.backup = this.clone();
}
// 恢复一个备忘录
public void restoreMemento() {
this.setState(this.backup.getState());
}
// 克隆当前对象
@Override
protected Originator clone() {
try {
return (Originator) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
备忘录管理员：
public class Caretaker {
// 发起人对象
private Originator originator;
public Originator getOriginator() {
return originator;
}
public void setOriginator(Originator originator) {
this.originator = originator;
}
}
场景类：
public class Client {
public static void main(String[] args) {
// 定义发起人
Originator originator = new Originator();
// 创建初始状态
originator.setState("初始状态");
System.out.println("初始状态：" + originator.getState());
// 创建备份
originator.createMemento();
// 修改状态
originator.setState("修改后的状态");
System.out.println("修改后的状态：" + originator.getState());
// 恢复状态
originator.restoreMemento();
System.out.println("恢复后的状态：" + originator.getState());
}
}
运行结果是我们所希望的，程序精简了很多，而且高层模块的依赖也减少了，这正是我们期望的效果。
但是我们来考虑一下原型模式深拷贝和浅拷贝的问题，在复杂的场景下它会让我们的程序逻辑异常混乱，出现错误也很难跟踪。因此 Clone 方式的备忘录模式适用于较简单的场景。
5. 多备份的备忘录
我们每天使用的 Windows 是可以拥有多个备份时间点的，系统出现问题，我们可以自由选择需要恢复的还原点。
我们上面的备忘录模式尚且不具有这个功能，只能有一个备份，想要有多个备份也比较简单，我们在备份的时候做一个标记，简单一点可以使用一个字符串。
我们只要把通用代码中的 Caretaker 管理员稍做修改就可以了：
public class Caretaker {
// 容纳备忘录的容器
private Map mementoMap = new HashMap<>();
public Memento getMemento(String keys) {
return mementoMap.get(keys);
}
public void setMemento(String key, Memento memento) {
this.mementoMap.put(key, memento);
}
}
对场景类做部分修改：
public class Client {
public static void main(String[] args) {
// 定义发起人
Originator originator = new Originator();
// 定义备忘录管理员
Caretaker caretaker = new Caretaker();
// 创建两个备忘录
caretaker.setMemento("001", originator.createMemento());
caretaker.setMemento("002", originator.createMemento());
// 恢复一个指定的备忘录
originator.restoreMemento(caretaker.getMemento("002"));
}
}
6. 更好的封装
在系统管理上，一个备份的数据是完全、绝对不能修改的，它保证数据的洁净，避免数据污染而使备份失去意义。
在我们的程序中也有着同样的问题，备份是不能被褚篡改的，那么也就是需要缩小备忘录的访问权限，保证只有发起人可读就可以了。
这个很简单，直接使用内置类就可以了：
public class Originator {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
// 创建一个备忘录
public IMemento createMemento() {
return new Memento(this.state);
}
// 恢复一个备忘录
public void restoreMemento(IMemento memento) {
this.setState(((Memento)memento).getState());
}
private class Memento implements IMemento {
private String state;
private Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
}
这里使用了一个 IMemento 接口，这个接口实际上是一个空接口：
public interface IMemento {
}
这个空接口的作用是用作公共的访问权限。
下面看一下备忘录管理者的变化：
public class Caretaker {
// 备忘录对象
private IMemento memento;
public IMemento getMemento() {
return memento;
}
public void setMemento(IMemento memento) {
this.memento = memento;
}
}
上面这段示例全部通过接口访问，如果我们想访问它的属性貌似是无法访问到了。
但是安全是相对的，没有绝对的安全，我们可以使用 refelect 反射修改 Memento 的数据。
在这里我们使用了一个新的设计方法：双接口设计，我们的一个类可以实现多个接口，在系统设计时，如果考虑对象的安全问题，则可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外一个接口是一个空接口，什么方法都没有，其目的是提供给子系统外的模块访问，比如容器对象，这个叫做窄接口，由于窄接口中没有提供任何操纵数据的方法，因此相对来说比较安全。
