备忘录模式
备忘录模式的定义
定义：在不破坏封装性的前提下，捕获一个对象内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
通俗地说，备忘录模式就是一个对象的备份模式，提供了一种程序数据的备份方法，通用类图如下：
角色定义
- Originator角色
记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。 - Memento备忘录角色
负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。 - Caretaker备忘录管理员角色
对备忘录进行管理、保存和提供备忘录。
通用代码
发起人角色
public class Originator {
/**
* 内部状态
*/
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
/**
* 创建一个备忘录
* @return
*/
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;
}
}
这是一个简单的JavaBean，备忘录管理者也是一个简单的JavaBean。
备忘录管理者
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());
}
}
备忘录模式的应用
由于备忘录模式有太多的变形和处理方式，每种方式都有它自己的优点和缺点，标准的备忘录模式很难在项目中遇到，基本上都有一些变换处理方式。 因此,我们在使用备忘录模式时主要了解如何应用以及需要注意哪些事项就成了。
使用场景
需要保存和恢复数据的相关状态场景。
提供个可回滚( rollback )的操作；比如Word中的CTRL+Z组合键，IE浏览器中的后退按钮，文件管理器上的backspace键等。
需要监控的副本场景中。例如要监控一个对象的属性，但是监控又不应该作为系统的主业务来调用，它只是边缘应用，即使出现监控不准、错误报警也影响不大，因此一般的做法是备份个主线程中的对象，然后由分析程序来分析。
数据库连接的事务管理就是用的备忘录模式，想想看， 如果你要实现一个JDBC驱动，你怎么来实现事务？还不是用备忘录模式嘛！
注意事项
- 备忘录的生命期
备忘录创建出来就要在“最近”的代码中使用，要主动管理它的生命周期，建立就要使用，不使用就要立刻删除其引用，等待垃圾回收器对它的回收处理。 - 备忘录的性能
不要在频繁建立备份的场景中使用备忘录模式(比如一个for循环中)，原因有二：一是控制不了备忘录建立的对象数量；二是大对象的建立是要消耗资源的，系统的性能需要考虑。因此，如果出现这样的代码，设计师就应该好好想想怎么修改架构了。
备忘录模式的扩展
clone方式的备忘录
类图如下：
从类图上来看，发起人角色融合了发起人角色和备忘录角色，具有双重功效，代码如下：
public class Originator implements Cloneable{
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public Originator createMemento(){
return this.clone();
}
//恢复一个备忘录
public void restoreMemento(Originator _originator){
this.setState(_originator.getState());
}
//克隆当前对象
@Override
protected Originator clone(){
try {
return (Originator)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
增加clone方法，产生了备份对象，需要使用的时候再还原
备忘录管理员角色
public class Caretaker {
//发起人对象
private Originator originator;
public Originator getOriginator() {
return originator;
}
public void setOriginator(Originator originator) {
this.originator = originator;
}
}
没有什么太大的变化，只是备忘录角色转换成了发起人角色，还是一个简单的JavaBean。继续简化上面的模式，可以把管理员角色也去掉。
发起人自主备份和恢复
public class Originator implements Cloneable{
private Originator backup;
/**
* 内部状态
*/
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public void createMemento(){
this.backup = this.clone();
}
public void restoreMemento(){
this.setState(backup.getState());
}
@Override
protected Originator clone(){
try{
return (Originator) super.clone();
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
return null;
}
}
场景类
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());
}
}
多状态的备忘录模式
在实际的开发中一个对象不可能只有一个状态一个JavaBean有多个属性非常常见，这都是它的状态，如果照搬我们以上讲解的备忘录模式，是不是就要写一堆的状态备份、还原语句？这不是一个好办法，这种类似的非智力劳动越多，犯错误的几率越大，那我们有什么办法来处理多个状态的备份问题呢？下面我们来讲解一个对象全状态备份方案，它有多种处理方式，比如使用Clone()的方式就可以解决，使用数据技术也可以解决(DTO回写到临时表中)等，我们要讲的方案就对备忘录模式继续扩展一下，实现一个JavaBean对象的所有状态的备份和还原,如下图。
还是比较简单的类图，增加了-个BeanUtils类，其中backupProp()是把发起人的所有属性值转换到HashMap中，方便备忘录角色存储；restoreProp()方法则是把HashMap中的值返回到发起人角色中。可能各位要说了，为什么要使用HashMap，直接使用Originator对象的拷贝不是一个很好的方法吗？可以这样做，你就破坏了发起人的通用性，你在做恢复动作的时候需要对该对象进行多次赋值操作,也容易产生错误。我们先来看发起人角色,如代码如下。
发起人角色
public class Originator {
private String state1 = "";
private String state2 = "";
private String state3 = "";
public String getState1() {
return state1;
}
public void setState1(String state1) {
this.state1 = state1;
}
public String getState2() {
return state2;
}
public void setState2(String state2) {
this.state2 = state2;
}
public String getState3() {
return state3;
}
public void setState3(String state3) {
this.state3 = state3;
}
/**
* 创建一个备忘录
*/
public Memento createMemento(){
return new Memento(BeanUtils.backkupProp(this));
}
public void restoreMemento(Memento memento) {
BeanUtils.restoreProp(this, memento.getStateMap());
}
@Override
public String toString() {
return "Originator{" +
"state1='" + state1 + '\'' +
", state2='" + state2 + '\'' +
", state3='" + state3 + '\'' +
'}';
}
}
BeanUtils工具类
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class BeanUtils {
/**
* 把bean中的所有属性及数值放入到HashMap中
*
* @param bean
* @return
*/
public static Map<String, Object> backkupProp(Object bean){
Map<String, Object> result = new HashMap<>();
try{
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//获取属性描述
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
//遍历所有属性
for (PropertyDescriptor des : descriptors) {
//属性名
String fieldName = des.getName();
//读取属性的方法
Method getter = des.getReadMethod();
//读取属性值
Object fieldValue = getter.invoke(bean, new Object[]{});
if (!fieldName.equalsIgnoreCase("class")) {
result.put(fieldName, fieldValue);
}
}
}catch (Exception e){
}
return result;
}
/**
* 把map中的值返回到bean中
*
* @param bean
* @param propMap
*/
public static void restoreProp(Object bean, Map<String, Object> propMap) {
try{
//获取ben描述
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//获取属性描述
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
//遍历所有属性
for (PropertyDescriptor des : descriptors) {
//属性名称
String fieldName = des.getName();
//如果有这个属性
if (propMap.containsKey(fieldName)) {
Method setter = des.getWriteMethod();
setter.invoke(bean, new Object[]{propMap.get(fieldName)});
}
}
}catch (Exception e){
}
}
}
备忘录角色
public class Memento {
private Map<String, Object> stateMap = new HashMap<>();
public Memento(Map<String, Object> map) {
this.stateMap = map;
}
public Map<String, Object> getStateMap() {
return stateMap;
}
public void setStateMap(Map<String, Object> stateMap) {
this.stateMap = stateMap;
}
}
场景类
public class Client {
public static void main(String[] args) {
//定义发起人
Originator originator = new Originator();
//定义备忘录管理员
Caretaker caretaker = new Caretaker();
//初始化
originator.setState1("中国");
originator.setState2("强盛");
originator.setState3("繁荣");
System.out.println("初始化状态：" + originator);
//创建一个备忘录
caretaker.setMemento(originator.createMemento());
//修改状态值
//初始化
originator.setState1("软件");
originator.setState2("架构");
originator.setState3("优秀");
System.out.println("\n==修改后的状态===\n：" + originator);
//恢复一个备忘录
originator.restoreMemento(caretaker.getMemento());
System.out.println("\n====恢复后的状态====\n:"+originator);
}
}
多备份的备忘录
不知道你有没有做过系统级别的维护？比如Backup Administrator (备份管理员)，每天负责查看系统的备份情况，所有的备份都是由自动化脚本产生的。有一天，突然有一个重要的系统说我数据库有点问题，请把上一个月末的数据拉出来恢复，那怎么办？对备份管理员来说，这很好办，直接根据时间戳找到这个备份,还原回去就成了，但是对于我们刚刚学习的备忘录模式却行不通,为什么呢？它对于一个确定的发起人，永远只有份备份，在这种情况下，单的备份就不能满足要求了，我们需要设计套多备份的架构。
我们先来说一个名词，检查点(Check Point)，也就是你在备份的时候做的戳记，系统级的备份一般是时间戳，那我们程序的检查点该怎么设计呢？一般是一个有意义的字符串。我们只要把通用代码中的Caretaker管理员稍做修改就可以了，如下代码。
备忘录管理员
public class Caretaker {
//容纳备忘录的容器
private Map<String, Memento> map = new HashMap<>();
public Memento getMemento(String idx){
return map.get(idx);
}
public void setMemento(String idx, Memento memento) {
this.map.put(idx, memento);
}
}
把容纳备忘录的容器修改为Map类型就可以了，场景类如下：
场景类
public class Client {
public static void main(String[] args) {
//定义发起人
Originator originator = new Originator();
//定义备忘录管理员
Caretaker caretaker = new Caretaker();
//初始化
originator.setState1("中国");
originator.setState2("强盛");
originator.setState3("繁荣");
System.out.println("初始化状态：" + originator);
//创建两个备忘录
caretaker.setMemento("001", originator.createMemento());
caretaker.setMemento("002", originator.createMemento());
//恢复一个指定标记的备忘录
originator.restoreMemento(caretaker.getMemento("002"));
}
}
注意：内存溢出问题，该备份旦产生就装入内存，没有任何销毁的意向，这是非常危险的。因此，在系统设计时,要严格限定备忘录的创建,建议增加Map的上限,否则系统很容易产生内存溢出情况。
封装优化
在系统管理上，一个备份的数据是完全、绝对不能修改的，它保证数据的洁净，避免数据污染而使备份失去意义。在我们的设计领域中，也存在着同样的问题，备份是不能被篡改的，也就是说需要缩小备份出的备忘录的阅读权限，保证只能是发起人可读就成了，那怎么才能做到这一点呢？使用内置类，如下图。
这也是比较简单的，建立一个空接IMemento什么方法属性都没有的接口，然后在发起人Originator类中建立一个内置类 (也叫做类中类)Memento实现IMemento接口，同时也实现自己的业务逻辑，如下代码。
发起人角色
public class Originator {
/**
* 内部状态
*/
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
/**
* 创建一个备忘录
* @return
*/
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;
}
private String getState() {
return state;
}
private void setState(String state) {
this.state = state;
}
}
}
内置类Memento全部是private的访问权限，也就是说除了发起人外,别人休想访问到，那如果要产生关联关系又应如何处理呢？通过接口!别忘记了我们还有一个空接是公共的访问权限，如下代码。
备忘录的空接口
public interface IMemento {
}
备忘录管理者
public class Caretaker {
private IMemento memento;
public IMemento getMemento() {
return memento;
}
public void setMemento(IMemento memento) {
this.memento = memento;
}
}
全部通过接口访问，这当然没有问题，如果你想访问它的属性那是肯定不行的。但是安全是相对的，没有绝对的安全，可以使用refelect反射修改Memento的数据。
在这里我们使用了一个新的设计方法：双接口设计，我们的一个类可以实现多个接口，在系统设计时，如果考虑对象的安全问题，则可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外个接口是一个空接口，什么方法都没有，其目的是提供给子系统外的模块访问，比如容器对象，这个叫做窄接口，由于窄接口中没有提供任何操纵数据的方法，因此相对来说比较安全。
