设计模式——备忘录模式

备忘录模式

备忘录模式（Memento Pattern）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

类图中的角色：

• Originator发起人角色：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
• Memento备忘录角色：负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。
• Caretaker备忘录管理员角色：对备忘录进行管理、保存和提供备忘录。

发起人角色Originator：

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()); 
    } 
}

备忘录角色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; 
    } 
}

备忘录管理员角色Caretaker：

public class Caretaker { 
    //备忘录对象 
    private Memento memento; 
    public Memento getMemento() { 
        return memento; 
    }
    public void setMemento(Memento memento) { 
        this.memento = memento; 
    } 
}

场景类Client：

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键等。
• 需要监控的副本场景中。例如要监控一个对象的属性，但是监控又不应该作为系统的主业务来调用，它只是边缘应用，即使出现监控不准、错误报警也影响不大，因此一般的做法是备份一个主线程中的对象，然后由分析程序来分析。
• 数据库连接的事务管理就是用的备忘录模式。

备忘录模式的注意事项

• 备忘录的生命期：备忘录创建出来就要在“最近”的代码中使用，要主动管理它的生命周期，建立就要使用，不使用就要立刻删除其引用，等待垃圾回收器对它的回收处理。
• 备忘录的性能：不要在频繁建立备份的场景中使用备忘录模式（比如一个for循环中），原因有二：一是控制不了备忘录建立的对象数量；二是大量对象的建立是要消耗资源的，系统的性能需要考虑。

备忘录模式的扩展

• clone方式的备忘录
• 多状态的备忘录模式
• 多备份的备忘录
• 封装得更好一点

---

备忘录模式的实例

小伙子追小姑凉，第一次追求失败，恢复原先状态然后进行第二次追求，直到最后成功。

（1）备忘录模式

public class Boy {
	private String state = "";
	public void changeState() {
		this.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;
	}	
}

import com.sfq.action.Boy;
import com.sfq.action.Caretaker;
public class Client {
	public static void main(String[] args) {
		Boy boy = new Boy();
		Caretaker caretaker = new Caretaker();
		boy.setState("心情很棒！");
		System.out.println("=====现在状态=====");
		System.out.println(boy.getState());
		caretaker.setMemento(boy.createMemento());
		boy.changeState();
		System.out.println("=====追女孩后状态=====");
		System.out.println(boy.getState());
		//追女孩失败后恢复原状
		boy.restoreMemento(caretaker.getMemento());
		System.out.println("=====恢复后的状态=====");
		System.out.println(boy.getState());
	}
}

结果
=====现在状态=====
心情很棒！
=====追女孩后状态=====
心情可能很不好
=====恢复后的状态=====
心情很棒！

这个备份者就类似于一个备份的仓库管理员，创建一个丢进去，需要的时候再拿出来。这就是备忘录模式。

（2）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;
	}
}

public class CaretakerOriginator {
	private Originator originator;
	public Originator getOriginator() {
		return originator;
	}
	public void setOriginator(Originator originator) {
		this.originator = originator;
	}	
}

由于管理员角色是为了管理备忘录角色，而现在备忘录角色被合并了，因此我们可以将其删除，并进行精简。

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(this.backup.getState());
	}
	//克隆当前对象
	@Override
	protected Originator clone() {
		try {
			return (Originator)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
}

当然，这与备忘录模式的定义不相符，它定义是“在该对象之外保存这个状态”，而我们却把这个状态保存在了发起人内部。是的，设计模式定义的诞生比Java的出世略早，它没有想到Java程序是这么有活力，有远见，而且在面向对象的设计中，即使把一个类封装在另一个类中也是可以做到的，何况一个小小的对象复制，这是它的设计模式完全没有预见到的，我们把它弥补回来。

public class Client1 {
	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方式的备忘录模式，可以使用在比较简单的场景或者比较单一的场景中，尽量不要与其他的对象产生严重的耦合关系。

（3）多状态的备忘录模式

以上讲解都是单状态的情况，在实际的开发中一个对象不可能只有一个状态。一个对象全状态备份方案，有多种处理方式，比如使用Clone的方式，使用数据技术（DTO回写到临时表中）等，我们使用对备忘录模式继续扩展的方式，实现一个JavaBean对象的所有状态的备份和还原。

public class Originator1 {
	//内部状态
	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 Memento1 createMemento() {
		return new Memento1(BeanUtils.backupProp(this));
	}
	//恢复一个备忘录
	public void restoreMemento(Memento1 memento) {
		BeanUtils.restoreProp(this,memento.getStateMap());
	}
	//增加一个toString方法
	@Override
	public String toString() {
		return "state1=" + state1 + "\nstate2=" + state2 + "\nstate3=" + state3;
	}
}

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;

public class BeanUtils {
	public static HashMap<String, Object> backupProp(Object bean) {
		HashMap<String, Object> result = new HashMap<String, Object>();
		try {
			//获得Bean描述
			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;
	}
	public static void restoreProp(Object bean,HashMap<String, Object> propMap) {
		try {
			//获得Bean描述
			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) {
			System.out.println("shit");
			e.printStackTrace();
		}
	}
}

import java.util.HashMap;
public class Memento1 {
	//接受HashMap作为状态
	private HashMap<String, Object> stateMap;
	//接受一个对象，建立一个备份
	public Memento1(HashMap<String, Object> stateMap) {
		this.stateMap = stateMap;
	}	
	public HashMap<String, Object> getStateMap() {
		return stateMap;
	}	
	public void setStateMap(HashMap<String, Object> stateMap) {
		this.stateMap = stateMap;
	}	
}

public class Caretaker1 {
	private Memento1 memento1;
	public Memento1 getMemento1() {
		return memento1;
	}
	public void setMemento1(Memento1 memento1) {
		this.memento1 = memento1;
	}	
}

import com.sfq.action.Caretaker1;
import com.sfq.action.Originator1;
public class Client2 {
	public static void main(String[] args) {
		Originator1 originator1 = new Originator1();
		Caretaker1 caretaker1 = new Caretaker1();
		originator1.setState1("中国");
		originator1.setState2("强盛");
		originator1.setState3("繁荣");
		System.out.println("=====初始化状态=====\n" + originator1);
		//创建一个备忘录
		caretaker1.setMemento1(originator1.createMemento());
		//修改状态
		originator1.setState1("软件");
		originator1.setState2("架构");
		originator1.setState3("优秀");
		System.out.println("\n=====修改后状态=====\n" + originator1);
		//恢复一个备忘录
		originator1.restoreMemento(caretaker1.getMemento1());
		System.out.println("\n=====恢复后状态=====\n" + originator1);
	}
}

结果
=====初始化状态=====
state1=中国
state2=强盛
state3=繁荣

=====修改后状态=====
state1=软件
state2=架构
state3=优秀

=====恢复后状态=====
state1=中国
state2=强盛
state3=繁荣

注意：如果要设计一个在运行期决定备份状态的框架，则建议采用AOP框架来实现，避免采用动态代理无谓地增加程序逻辑复杂性。

（4）多备份的备忘录

这里涉及到一个名词——检查点（Check Point），也就是你在备份的时候做的戳记，系统级的备份一般是时间戳。

我们只要把通用代码中的Caretaker管理员添加一个容器就可以了：

public class Caretaker { 
    //容纳备忘录的容器 
    private HashMap<String,Memento> memMap = new HashMap<String,Memento>(); 
    public Memento getMemento(String idx) { 
        return memMap.get(idx); 
    }
    public void setMemento(String idx,Memento memento) { 
        this.memMap.put(idx, 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("001")); 
    } 
}

注意：内存溢出问题，该备份一旦产生就装入内存，没有任何销毁的意向，这是非常危险的。因此，在系统设计时，要严格限定备忘录的创建，建议增加Map的上限，否则系统很容易产生内存溢出情况。

（5）封装得更好一点

在系统管理上，一个备份的数据是完全、绝对不能修改的，它保证数据的洁净，避免数据污染而使备份失去意义。

建立一个空接口IMemento——什么方法属性都没有的接口，然后在发起人Originator类中建立一个内置类（也叫做类中类）Memento实现IMemento接口，同时也实现自己的业务逻辑。

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;
        }
        private String getState() { 
            return state; 
        }
        private void setState(String state) { 
            this.state = state; 
        } 
    } 
} 

public interface IMemento { 

}

public class Caretaker { 
    //备忘录对象 
    private IMemento memento; 
    public IMemento getMemento() { 
        return memento; 
    }
    public void setMemento(IMemento memento) { 
        this.memento = memento; 
    } 
}

全部通过接口访问，这当然没有问题，如果你想访问它的属性那是肯定不行的。但是安全是相对的，没有绝对的安全，可以使用refelect反射修改Memento的数据。

在这里我们使用了一个新的设计方法：双接口设计，我们的一个类可以实现多个接口，在系统设计时，如果考虑对象的安全问题，则可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外一个接口是一个空接口，什么方法都没有，其目的是提供给子系统外的模块访问，比如容器对象，这个叫做窄接口，由于窄接口中没有提供任何操纵数据的方法，因此相对来说比较安全。