备忘录模式
在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态
1. UML类图
2. 定义
通俗地说,备忘录模式就是一个对象的备份模式,提供了一种程序数据的备份方法
- Originator发起人角色:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和备份备忘录数据
- Memento备忘录角色:负责存储Originator发起人对象的内部状态,在需要的时候提供发起人需要的状态
- Caretaker备忘录管理员角色:对备忘录进行管理、保存和提供备忘录
3. 通用代码
//发起人角色
public class Originator{
//内部状态
private String state = "";
public String getState(){
return state;
}
public void setState(String state){
this.state = state;
}
//创建一个备忘录
public Memeto 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.getMementor());
}
}
4. 应用
4.1 使用场景
- 需要保存和恢复数据的相关状态场景
- 提供一个可回滚的操作
- 需要监控的副本场景中
- 数据库连接的事务管理就是用的是备忘录模式
4.2 注意事项
- 备忘录的生命期:备忘录创建出来就要在“最近”的代码中使用,要主动管理它的声明周期
- 备忘录的性能:不要再频繁建立备份的场景中使用备忘录模式,原有有
- 控制不了备忘录建立的对象数量
- 大对象的建立是要消耗资源的,系统的性能需要考虑
5. 扩展
5.1 clone方式的备忘录
精简了程序,高层模块的依赖也少了,可用于比较简单的场景或者比较单一的场景中,尽量不要与其他的对象产生耦合关系
//发起人自主备份和恢复
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;
}
}
//场景类
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());
}
}
5.2 多状态的备忘录模式
如果要设计一个在运行期决定备份状态的框架,则建议采用AOP框架来实现,避免采用动态代理无谓地增加程序逻辑复杂性
//发起者
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.backupProp(this));
}
//恢复一个备忘录
public void restoreMemento(Memento _memento){
BeanUtils.restoreProp(this, _memento.getStateMap());
}
//增加一个toString方法
@Override
public String toString(){
return "state1=" +state1+"\nstat2="+state2+"\nstate3="+state3;
}
}
//BeanUtils工具类
public class BeanUtils {
//把bean的所有属性及数值放入到Hashmap中
public static HashMap backupProp(Object bean){
HashMap result = new HashMap();
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;
}
//把HashMap的值返回到bean中
public static void restoreProp(Object bean,HashMap 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();
}
}
}
//备忘录角色
public class Memento {
//接受HashMap作为状态
private HashMap stateMap;
//接受一个对象,建立一个备份
public Memento(HashMap map){
this.stateMap = map;
}
public HashMap getStateMap() {
return stateMap;
}
public void setStateMap(HashMap stateMap) {
this.stateMap = stateMap;
}
}
//场景类
public class Client {
public static void main(String[] args) {
//定义出发起人
Originator ori = new Originator();
//定义出备忘录管理员
Caretaker caretaker = new Caretaker();
//初始化
ori.setState1("中国");
ori.setState2("强盛");
ori.setState3("繁荣");
System.out.println("===初始化状态===\n"+ori);
//创建一个备忘录
caretaker.setMemento(ori.createMemento());
//修改状态值
ori.setState1("软件");
ori.setState2("架构");
ori.setState3("优秀");
System.out.println("\n===修改后状态===\n"+ori);
//恢复一个备忘录
ori.restoreMemento(caretaker.getMemento());
System.out.println("\n===恢复后状态===\n"+ori);
}
}
5.3 多备份的备忘录
检查点(Check Point),也就是你在备份的时候做的戳记,系统级的备份一般是时间戳, 我们只要把通用代码中的Caretaker管理员稍做修改就可以了
可能出现内存溢出问题,该备份一旦产生就装入内存,没有任何销毁的意向,非常危险。所以建议限制Map的上限
//备忘录管理员
public class Caretaker {
//容纳备忘录的容器
private HashMap memMap = new HashMap();
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"));
}
}
5.4 封装得更好一点
一个备份的数据是完全、绝对不能修改的,它保证数据的洁净,避免数据污染而使备份失去意义备份是不能被篡改的,也就是说需要缩小备份出的备忘录的阅读权限,保证只能是发起人可读就成
这里通过内置了Memento来实现,设置成private禁止他人访问,产生关联关系则通过空接口来处理。它具有公共的访问权限
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;
}
}