设计模式--备忘录模式C++实现
备忘录模式C++实现
1定义Memento pattern
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先的状态
2类图
3实现
class Originator
{
private:
string state;
public:
string getState();
void setState(string &x);
Memento creatMemento()
{
return new Memento(state);
}
void restoreMemento(Memento men)
{
setState(men.getState());
}
};
class Memento
{
public:
Memento(string st)
:state(st)
{}
string getState()
{
return state;
}
void setState(string st)
{
state = st;
}
};
//备忘录管理员角色
class Caretaker
{
private:
Memento memento;
Memento getMemento()
{return memento;}
void setMemento(string st)
{memento = st;}
};
class Client
{
public:
void operator()()
{
Originator or= new Originator();
Caretaker ca = new Caretaker();
//管理员备忘记录设置为用户定义为备忘状态
ca.setMemento(or.createMemento());
//用户重新会退到管理员记录的某一状态
or.restoreMemento(ca.getMemento());
}
};
4应用
使用场景
需要提供保存和恢复数据的相关状态场景
提供一个可回滚rollback操作
需要监控的副本场景。
数据库连接的事务管理就是备忘录模式
注意事项：
备忘录的声明期：作用在最近的代码。不使用就立即删除。..备忘录不是华佗在世，起死回生
备忘录的性能：不能用在for中，不能用频繁建立。消耗资源太多，这会是设计重构的前兆
5扩展
clone方式的备忘录
实现
class Originator :public Cloneable
{
private:
string state;
public:
void setState(string st);
Originator creatorMemento()
{
return clone();
}
restoreMemento(Originator or)
{
setState(or.getState);
}
Originator clone()
{
//其实就是拷贝构造一个
}
};
class Caretaker
{
private:
Originator or;
Originator getOriginator()
{
return or;
}
void setOriginator(Originator originator)
{
or = originator;
}
}
既然可以合并备忘录角色，那么管理员也是可以合并的
∴
class Originator :public Cloneable
{
private:
Originator* _backup;
string _state;
public:
Originator(const Originator& or)
{}
void setState();
void creatMemento()
{
_bcakup = new Originator(*this);
}
void restoreMemento()
{
assert(_backup);
setStat(_backup->getState);
}
};
注：因为clone方式的备忘录可能会因为深浅拷贝问题而复杂，所以clone方式的备忘录适用简单的场景
②多状态备忘录
在Originator中封装多个状态，而Memento则保存一个HashMap 的state
③多备份的备忘录
注：管理员角色封装一的HashMap封装一个备忘录而非备忘状态
eg
class Caretaker
{
private:
HashMap<string,Memento> memMap;
public:
Memento getMemento(stirng index)
{}
void setMemento(string index,Memento me)
{
memMap.put(index,me);
}
};
void Test
{
Originator or = new Originator();
Caretaker ca = new Caretaker();
ca.setMemento("001",or.createMemento());
ca.setMemento("002",or.createMemento());
or.restoreMemento(ca.getMemento("001"));
}
注：该模式下应当注意备忘录上限，控制内存
提升：提供权限问题
class Originator
{
private:
string state;
public:
void setState(string st);
Imemento createMemento()
{
return new Memento(state);
}
void restoreMemento(Imemento me)
{
setState(me.getState());
}
private:
//内置类，实现
class Memento :public IMemento
{
private:
string state;
Memento(string st)
{
state = st;
}
string getState();
void setState(string st);
};
};
class Imemento
{
public:
virtual ~Imemento()=0;
};
class Caretaker
{
Imemento memento;
public:
Imemento getMemento()
{
return memento;
}
void setMemento(Imemento mem)
{
memento = mem;
}
};
注：这里的设计方案：双接口设计，一个是业务的正常接口，实现必要的业务逻辑，宽接口；另一个则是空接口，什么方法都没有，目的是提供给子系统外的模块访问，窄接口。窄接口中没有任何操纵数据的方法，所以是相对安全的。
