【设计模式】备忘录模式教你怎样优雅地处置惩罚状态快照 ...

概述

备忘录模式提供了一种状态规复的实现机制，使得用户可以方便地回到一个特定的历史步调，当新的状态无效大概存在问题时，可以使用暂时存储起来的备忘录将状态复原，很多软件都提供了打消（Undo）操纵，如 Word、记事本、Photoshop、IDEA等软件在编辑时按 Ctrl+Z 组合键时能打消当前操纵，使文档规复到之前的状态；另有在浏览器中的退却键、数据库事务管理中的回滚操纵、玩游戏时的中间结果存档功能、数据库与操纵体系的备份操纵、棋类游戏中的悔棋功能等都属于这类。
定义：
又叫快照模式，在不粉碎封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象规复到原先保存的状态。
结构

备忘录模式的重要角色如下：

• 发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和规复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的全部信息。
  
• 备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
  
• 管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。
  

备忘录有两个等效的接口：
窄接口：管理者(Caretaker)对象（和其他发起人对象之外的任何对象）看到的是备忘录的窄接口(narror Interface)，这个窄接口只答应他把备忘录对象传给其他的对象。但是不答应访问和修改备忘录
宽接口：与管理者看到的窄接口相反，发起人对象可以看到一个宽接口(wide Interface)，这个宽接口答应它读取全部的数据，以便根据这些数据规复这个发起人对象的内部状态。
案例实现

【例】游戏挑战BOSS
游戏中的某个场景，一游戏角色有生命力、攻击力、防御力等数据，在打Boss前和后肯定会不一样的，我们答应玩家如果感觉与Boss决斗的结果不理想可以让游戏规复到决斗之前的状态。
要实现上述案例，有两种方式：

• “白箱”备忘录模式
  
• “黑箱”备忘录模式
  

“白箱”备忘录模式

备忘录角色对任何对象都提供一个接口，即宽接口，备忘录角色的内部所存储的状态就对全部对象公开。类图如下：

代码如下：

1. //游戏角色类
2. public class GameRole {
3.     private int vit; //生命力
4.     private int atk; //攻击力
5.     private int def; //防御力
7.     //初始化状态
8.     public void initState() {
9.         this.vit = 100;
10.         this.atk = 100;
11.         this.def = 100;
12.     }
14.     //战斗
15.     public void fight() {
16.         this.vit = 0;
17.         this.atk = 0;
18.         this.def = 0;
19.     }
21.     //保存角色状态
22.     public RoleStateMemento saveState() {
23.         return new RoleStateMemento(vit, atk, def);
24.     }
26.     //回复角色状态
27.     public void recoverState(RoleStateMemento roleStateMemento) {
28.         this.vit = roleStateMemento.getVit();
29.         this.atk = roleStateMemento.getAtk();
30.         this.def = roleStateMemento.getDef();
31.     }
33.     public void stateDisplay() {
34.         System.out.println("角色生命力：" + vit);
35.         System.out.println("角色攻击力：" + atk);
36.         System.out.println("角色防御力：" + def);
37.     }
39.     public int getVit() {
40.         return vit;
41.     }
43.     public void setVit(int vit) {
44.         this.vit = vit;
45.     }
47.     public int getAtk() {
48.         return atk;
49.     }
51.     public void setAtk(int atk) {
52.         this.atk = atk;
53.     }
55.     public int getDef() {
56.         return def;
57.     }
59.     public void setDef(int def) {
60.         this.def = def;
61.     }
62. }
64. //游戏状态存储类(备忘录类)
65. public class RoleStateMemento {
66.     private int vit;
67.     private int atk;
68.     private int def;
70.     public RoleStateMemento(int vit, int atk, int def) {
71.         this.vit = vit;
72.         this.atk = atk;
73.         this.def = def;
74.     }
76.     public int getVit() {
77.         return vit;
78.     }
80.     public void setVit(int vit) {
81.         this.vit = vit;
82.     }
84.     public int getAtk() {
85.         return atk;
86.     }
88.     public void setAtk(int atk) {
89.         this.atk = atk;
90.     }
92.     public int getDef() {
93.         return def;
94.     }
96.     public void setDef(int def) {
97.         this.def = def;
98.     }
99. }
101. //角色状态管理者类
102. public class RoleStateCaretaker {
103.     private RoleStateMemento roleStateMemento;
105.     public RoleStateMemento getRoleStateMemento() {
106.         return roleStateMemento;
107.     }
109.     public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
110.         this.roleStateMemento = roleStateMemento;
111.     }
112. }
114. //测试类
115. public class Client {
116.     public static void main(String[] args) {
117.         System.out.println("------------大战Boss前------------");
118.         //大战Boss前
119.         GameRole gameRole = new GameRole();
120.         gameRole.initState();
121.         gameRole.stateDisplay();
123.         //保存进度
124.         RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
125.         roleStateCaretaker.setRoleStateMemento(gameRole.saveState());
127.         System.out.println("------------大战Boss后------------");
128.         //大战Boss时，损耗严重
129.         gameRole.fight();
130.         gameRole.stateDisplay();
131.         System.out.println("------------恢复之前状态------------");
132.         //恢复之前状态
133.         gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
134.         gameRole.stateDisplay();
136.     }
137. }

复制代码

分析：白箱备忘录模式是粉碎封装性的。但是通过程序员自律，同样可以在肯定程度上实现模式的大部分用意。
“黑箱”备忘录模式

备忘录角色对发起人对象提供一个宽接口，而为其他对象提供一个窄接口。在Java语言中，实现双重接口的办法就是将备忘录类设计成发起人类的内部成员类。
将 RoleStateMemento 设为 GameRole 的内部类，从而将 RoleStateMemento 对象封装在 GameRole 里面；在表面提供一个标识接口 Memento 给 RoleStateCaretaker 及其他对象使用。这样 GameRole 类看到的是 RoleStateMemento 全部的接口，而RoleStateCaretaker 及其他对象看到的仅仅是标识接口 Memento 所袒暴露来的接口，从而维护了封装型。类图如下：

代码如下：
窄接口Memento，这是一个标识接口，因此没有定义出任何的方法

1. public interface Memento {
2. }

复制代码

定义发起人类 GameRole，并在内部定义备忘录内部类 RoleStateMemento（该内部类设置为私有的）

1. //游戏角色类
2. public class GameRole {
3.     private int vit; //生命力
4.     private int atk; //攻击力
5.     private int def; //防御力
7.     //初始化状态
8.     public void initState() {
9.         this.vit = 100;
10.         this.atk = 100;
11.         this.def = 100;
12.     }
14.     //战斗
15.     public void fight() {
16.         this.vit = 0;
17.         this.atk = 0;
18.         this.def = 0;
19.     }
21.     //保存角色状态
22.     public Memento saveState() {
23.         return new RoleStateMemento(vit, atk, def);
24.     }
26.     //回复角色状态
27.     public void recoverState(Memento memento) {
28.         RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
29.         this.vit = roleStateMemento.getVit();
30.         this.atk = roleStateMemento.getAtk();
31.         this.def = roleStateMemento.getDef();
32.     }
34.     public void stateDisplay() {
35.         System.out.println("角色生命力：" + vit);
36.         System.out.println("角色攻击力：" + atk);
37.         System.out.println("角色防御力：" + def);
38.     }
40.     public int getVit() {
41.         return vit;
42.     }
44.     public void setVit(int vit) {
45.         this.vit = vit;
46.     }
48.     public int getAtk() {
49.         return atk;
50.     }
52.     public void setAtk(int atk) {
53.         this.atk = atk;
54.     }
56.     public int getDef() {
57.         return def;
58.     }
60.     public void setDef(int def) {
61.         this.def = def;
62.     }
64.     private class RoleStateMemento implements Memento {
65.         private int vit;
66.         private int atk;
67.         private int def;
69.         public RoleStateMemento(int vit, int atk, int def) {
70.             this.vit = vit;
71.             this.atk = atk;
72.             this.def = def;
73.         }
75.         public int getVit() {
76.             return vit;
77.         }
79.         public void setVit(int vit) {
80.             this.vit = vit;
81.         }
83.         public int getAtk() {
84.             return atk;
85.         }
87.         public void setAtk(int atk) {
88.             this.atk = atk;
89.         }
91.         public int getDef() {
92.             return def;
93.         }
95.         public void setDef(int def) {
96.             this.def = def;
97.         }
98.     }
99. }

复制代码

负责人角色类 RoleStateCaretaker 能够得到的备忘录对象是以 Memento 为接口的，由于这个接口仅仅是一个标识接口，因此负责人角色不可能改变这个备忘录对象的内容

1. //角色状态管理者类
2. public class RoleStateCaretaker {
3.     private Memento memento;
5.     public Memento getMemento() {
6.         return memento;
7.     }
9.     public void setMemento(Memento memento) {
10.         this.memento = memento;
11.     }
12. }

复制代码

客户端测试类

1. public class Client {
2.     public static void main(String[] args) {
3.         System.out.println("------------大战Boss前------------");
4.         //大战Boss前
5.         GameRole gameRole = new GameRole();
6.         gameRole.initState();
7.         gameRole.stateDisplay();
9.         //保存进度
10.         RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
11.         roleStateCaretaker.setMemento(gameRole.saveState());
12.         
13.         System.out.println("------------大战Boss后------------");
14.         //大战Boss时，损耗严重
15.         gameRole.fight();
16.         gameRole.stateDisplay();
17.         System.out.println("------------恢复之前状态------------");
18.         //恢复之前状态
19.         gameRole.recoverState(roleStateCaretaker.getMemento());
20.         gameRole.stateDisplay();
21.     }
22. }

复制代码

优缺点

长处：

• 提供了一种可以规复状态的机制。当用户需要时能够比力方便地将数据规复到某个历史的状态。
  
• 实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能够访问这些状态信息。
  
• 简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，全部状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。
  

缺点：

• 资源消耗大。如果要保存的内部状态信息过多大概特殊频仍，将会占用比力大的内存资源。
  

使用场景

• 需要保存与规复数据的场景，如玩游戏时的中间结果的存档功能。
  
• 需要提供一个可回滚操纵的场景，如 Word、记事本、Photoshop，idea等软件在编辑时按 Ctrl+Z 组合键，另有数据库中事务操纵。
  

往期推荐

• 《SpringBoot》EasyExcel实现百万数据的导入导出
  
• 《SpringBoot》史上最全SpringBoot相关注解介绍
  
• Spring框架IoC核心详解
  
• 万字长文带你窥伺Spring中全部的扩展点
  
• 怎样实现一个通用的接口限流、防重、防抖机制
  
• 万字长文带你深入Redis底层数据结构
  
• volatile关键字最全原理剖析
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。