【设计模式】—-（18）备忘录模式（行为型）

备忘录模式（Token）

一、定义

在不破坏封闭的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

二、适用场景

适合于功能比较复杂，但需要维护或记录属性历史的功能。

参与者：

      Originator(发起人)：负责创建一个备忘录Memento，用以记录当前时刻自身的内部状态，并可使用备忘录恢复内部状态。Originator可以根据需要决定Memento存储自己的哪些内部状态。

　　Memento(备忘录)：负责存储Originator对象的内部状态，并可以防止Originator以外的其他对象访问备忘录。备忘录有两个接口：Caretaker只能看到备忘录的窄接口，他只能将备忘录传递给其他对象。Originator却可看到备忘录的宽接口，允许它访问返回到先前状态所需要的所有数据。

　　Caretaker(管理者):负责备忘录Memento，不能对Memento的内容进行访问或者操作。

适用性：

1）必须保存一个对象在某一时刻的（部分）状态，这样以后需要时它才能恢复到先前的状态。

2）如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

效果：

1）保持封装边界

2）简化原发器

3）使用备忘录可能代价很高

4）定义窄接口和宽接口

5）维护备忘录的潜在代价

三、UML

四、代码

1. /**
   
2.  * 游戏自身（备忘录模式中的发起人，备份的是游戏的状态）
   
3.  */
   
4. public class Game {
   
5. 
   
6.     /**
   
7.      * 英雄状态属性
   
8.      */
   
9.     private HeroState hState;
   
10. 
    
11.     /**
    
12.      * 场景状态属性
    
13.      */
    
14.     private SceneState sState;
    
15. 
    
16.     public HeroState gethState() {
    
17.         return hState;
    
18.     }
    
19. 
    
20.     public void sethState(HeroState hState) {
    
21.         this.hState = hState;
    
22.     }
    
23. 
    
24.     public SceneState getsState() {
    
25.         return sState;
    
26.     }
    
27. 
    
28.     public void setsState(SceneState sState) {
    
29.         this.sState = sState;
    
30.     }
    
31. 
    
32.     /**
    
33.      * 备份游戏
    
34.      */
    
35.     public GameMemento createMemento(){
    
36.         return new GameMemento(hState,sState);
    
37.     }
    
38.     
    
39.     /**
    
40.      * 玩游戏
    
41.      * @throws InterruptedException 
    
42.      */
    
43.     public void play(){
    
44.         hState.setHP(0);
    
45.         hState.setMP(0);
    
46.         sState.setCoin(0);
    
47.         sState.setWood(0);
    
48.     }
    
49.     
    
50.     /**
    
51.      * 游戏还原
    
52.      */
    
53.     public void restore(GameMemento memento){
    
54.         this.hState = memento.gethState();
    
55.         this.sState = memento.getsState();
    
56.     }
    
57. }

2、第二个文件要备份的状态实体：HeroState.java 

点击(此处)折叠或打开

1. /**
   
2.  * 游戏英雄人物状态实体 
   
3.  */
   
4. public class HeroState implements Cloneable{
   
5. 
   
6.     /**
   
7.      * 英雄生命值
   
8.      */
   
9.     private int HP;
   
10.     
    
11.     /**
    
12.      * 英雄魔法值
    
13.      */
    
14.     private int MP;
    
15.     
    
16.     /**
    
17.      * 状态保存时间
    
18.      */
    
19.     private Date stateDate;
    
20. 
    
21.     public int getHP() {
    
22.         return HP;
    
23.     }
    
24. 
    
25.     public void setHP(int hP) {
    
26.         HP = hP;
    
27.     }
    
28. 
    
29.     public int getMP() {
    
30.         return MP;
    
31.     }
    
32. 
    
33.     public void setMP(int mP) {
    
34.         MP = mP;
    
35.     }
    
36. 
    
37.     public Date getStateDate() {
    
38.         return stateDate;
    
39.     }
    
40. 
    
41.     public void setStateDate(Date stateDate) {
    
42.         this.stateDate = stateDate;
    
43.     }
    
44.     
    
45.     public HeroState clone(){
    
46.         try {
    
47.             return (HeroState) super.clone();
    
48.         } catch (CloneNotSupportedException e) {
    
49.             // TODO Auto-generated catch block
    
50.             e.printStackTrace();
    
51.         }
    
52.         return null;
    
53.     }
    
54. }

3、要备份的状态实体：SceneState.java 

点击(此处)折叠或打开

1. /**
   
2.  * 游戏场景状态实体 
   
3.  */
   
4. public class SceneState implements Cloneable{
   
5. 
   
6.     /**
   
7.      * 金币数量
   
8.      */
   
9.     private int coin;
   
10.     
    
11.     /**
    
12.      * 木材数量
    
13.      */
    
14.     private int wood;
    
15.     
    
16.     /**
    
17.      * 地图名称
    
18.      */
    
19.     private String mapName;
    
20. 
    
21.     public int getCoin() {
    
22.         return coin;
    
23.     }
    
24. 
    
25.     public void setCoin(int coin) {
    
26.         this.coin = coin;
    
27.     }
    
28. 
    
29.     public int getWood() {
    
30.         return wood;
    
31.     }
    
32. 
    
33.     public void setWood(int wood) {
    
34.         this.wood = wood;
    
35.     }
    
36. 
    
37.     public String getMapName() {
    
38.         return mapName;
    
39.     }
    
40. 
    
41.     public void setMapName(String mapName) {
    
42.         this.mapName = mapName;
    
43.     }
    
44.     
    
45.     public SceneState clone(){
    
46.         try {
    
47.             return (SceneState) super.clone();
    
48.         } catch (CloneNotSupportedException e) {
    
49.             // TODO Auto-generated catch block
    
50.             e.printStackTrace();
    
51.         }
    
52.         return null;
    
53.     }
    
54. }

4、第四个文件备忘录角色：GameMemcento.java 

点击(此处)折叠或打开

1. /**
   
2.  * 游戏备忘录角色
   
3.  */
   
4. public class GameMemento{
   
5. 
   
6.     /**
   
7.      * 英雄状态
   
8.      */
   
9.     private HeroState hState;
   
10.     
    
11.     /**
    
12.      * 场景状态
    
13.      */
    
14.     private SceneState sState;
    
15.     
    
16.     /**
    
17.      * 构造方法
    
18.      * @param hState
    
19.      * @param sState
    
20.      */
    
21.     public GameMemento(HeroState hState,SceneState sState){
    
22.         this.hState = hState.clone();
    
23.         this.sState = sState.clone();
    
24.     }
    
25. 
    
26.     /**
    
27.      * 获取备份状态
    
28.      * @return
    
29.      */
    
30.     public HeroState gethState() {
    
31.         return hState;
    
32.     }
    
33. 
    
34.     /**
    
35.      * 获取备份状态
    
36.      * @return
    
37.      */
    
38.     public SceneState getsState() {
    
39.         return sState;
    
40.     }
    
41. }

5、第五个文件备忘录管理角色：Caretaker.java 

点击(此处)折叠或打开

1. /**
   
2.  * 备忘录管理器
   
3.  */
   
4. public class Caretaker {
   
5. 
   
6.     /**
   
7.      * 备忘录实体
   
8.      */
   
9.     private GameMemento memento;
   
10. 
    
11.     public GameMemento getMemento() {
    
12.         return memento;
    
13.     }
    
14. 
    
15.     public void setMemento(GameMemento memento) {
    
16.         this.memento = memento;
    
17.     }
    
18. }

6、第六个文件：TestMain.java 

点击(此处)折叠或打开

1. /**
   
2.  * 测试Main方法
   
3.  */
   
4. public class TestMain {
   
5. 
   
6.     public static void main(String [] args){
   
7.         Game game = new Game();
   
8.         HeroState hState = new HeroState();
   
9.         hState.setHP(100);
   
10.         hState.setMP(100);
    
11.         SceneState sState = new SceneState();
    
12.         sState.setCoin(1000);
    
13.         sState.setWood(1000);
    
14.         game.sethState(hState);
    
15.         game.setsState(sState);
    
16.         System.out.println("游戏状态备份开始");
    
17.         GameMemento memento = game.createMemento();
    
18.         Caretaker ct = new Caretaker();
    
19.         ct.setMemento(memento);
    
20.         System.out.println("游戏状态备份完成");
    
21.         System.out.println("开始游戏，当前英雄生命值：" + game.gethState().getHP());
    
22.         game.play();
    
23.         System.out.println("游戏结束，当前英雄生命值：" + game.gethState().getHP());
    
24.         System.out.println("游戏状态还原开始");
    
25.         game.restore(ct.getMemento());
    
26.         System.out.println("游戏状态还原结束");
    
27.         System.out.println("当前英雄生命值：" + game.gethState().getHP());
    
28.     }
    
29. }

五、总结

备忘录模式

优点：

1）在同一个集合上可有多个状态一起工作

2）不需要为支持迭代而破坏一个集合的封装性。

缺点：

将对象状态备份会占用比较多的系统资源。