中介者模式与备忘录模式
参考教程:https://www.bilibili.com/video/BV1G4411c7N4
代码实现 Github:https://github.com/yaokuku123/pattern
中介者模式
- 案例
智能家庭项目: 1) 智能家庭包括各种设备,闹钟、咖啡机、电视机、窗帘等 2) 主人要看电视时,各个设备可以协同工作,自动完成看电视的准备工作,比如流 程为:闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放
- 传统方式
![](https://i-blog.csdnimg.cn/blog_migrate/b4f283bf8d9b9ba27231abe71cf6a759.png)
- 分析
- 当各电器对象有多种状态改变时,相互之间的调用关系会比较复杂 2) 各个电器对象彼此联系,你中有我,我中有你,不利于松耦合. 3) 各个电器对象之间所传递的消息(参数),容易混乱 4) 当系统增加一个新的电器对象时,或者执行流程改变时,代码的可维护性、扩展性都不理想
- 中介者模式
解释:用一个中介对象来封装一系列的对象交互。 中介者使各个对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。比如MVC模式,C(Controller控制器)是M(Model模型)和V(View视图)的中介者,在前后端交互时起到了中间人的作用
- 代码实现
![](https://i-blog.csdnimg.cn/blog_migrate/744122ce2b772c2e27aa8961ea79dca1.png)
对原理类图的说明-即(中介者模式的角色及职责)
Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
Colleague 是抽象同事类
ConcreteMediator 具体的中介者对象, 实现抽象方法, 他需要知道所有的具体的同事类,即以一个集合来管理并接受某个同事对象的消息,完成对应任务
ConcreteColleague 具体的同事类,有多个,每个同事只知道自己的行为,而不了解其他同事类的行为(方法),他们均依赖中介对象
<img src="img/4-1592963349506.png" alt="4" style="zoom:80%;" />
package com.yqj.pattern.mediator;
import java.util.HashMap;
import java.util.Map;
//中介者抽象类
abstract class Mediator {
//将同事对象加入到集合
public abstract void register(String colleagueName, Colleague colleague);
//接受消息,消息由具体的同事对象发出
public abstract void getMessage(int stateChange, String colleagueName);
}
//具体的中介者类
class ConcreteMediator extends Mediator {
//集合,存放所有同事对象
private Map<String, Colleague> colleagueMap;
private Map<String, String> internalMap;
public ConcreteMediator() {
colleagueMap = new HashMap<>();
internalMap = new HashMap<>();
}
@Override
public void register(String colleagueName, Colleague colleague) {
//将同事放入集合
colleagueMap.put(colleagueName, colleague);
//自定义映射字段
if (colleague instanceof Alarm) {
internalMap.put("alarm", colleagueName);
} else if (colleague instanceof TV) {
internalMap.put("TV", colleagueName);
} else if (colleague instanceof Curtains) {
internalMap.put("curtains", colleagueName);
} else if (colleague instanceof CoffeeMachine) {
internalMap.put("coffeeMachine", colleagueName);
}
}
//中介者核心方法
//1.根据得到的消息,完成对应任务
//2.中介者在这人方法中协调哥哥具体的同事对象完成任务
@Override
public void getMessage(int stateChange, String colleagueName) {
//处理闹钟发出的消息
if (colleagueMap.get(colleagueName) instanceof Alarm) {
if (stateChange == 0) {
((CoffeeMachine) (colleagueMap.get(internalMap.get("coffeeMachine")))).startCoffee();
((TV) (colleagueMap.get(internalMap.get("TV")))).startTv();
} else if (stateChange == 1) {
((TV) (colleagueMap.get(internalMap.get("TV")))).stopTv();
}
} else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
if (stateChange == 0) {
((Curtains) (colleagueMap.get(internalMap.get("curtains")))).upCurtains();
}
} else if (colleagueMap.get(colleagueName) instanceof TV) {
//..
} else if (colleagueMap.get(colleagueName) instanceof Curtains) {
//..
}
}
}
//同事抽象类
abstract class Colleague {
private String name;
private Mediator mediator;
public Colleague(String name, Mediator mediator) {
this.name = name;
this.mediator = mediator;
}
public abstract void sendMessage(int stateChange);
public Mediator getMediator() {
return mediator;
}
public String getName() {
return name;
}
}
class Alarm extends Colleague {
public Alarm(String name, Mediator mediator) {
super(name, mediator);
//在创建同事对象时,将自己放入到ConcreteMediator 对象的集合中,让中介者来管理
mediator.register(name, this);
}
public void sendAlarm(int stateChange) {
sendMessage(stateChange);
}
//给中介者对象方式信息
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.getName());
}
}
class TV extends Colleague {
public TV(String name, Mediator mediator) {
super(name, mediator);
mediator.register(name, this);
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.getName());
}
public void startTv() {
System.out.println("打开电视机");
}
public void stopTv() {
System.out.println("关闭电视机");
}
}
class Curtains extends Colleague {
public Curtains(String name, Mediator mediator) {
super(name, mediator);
mediator.register(name, this);
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.getName());
}
public void upCurtains() {
System.out.println("打开窗帘");
}
}
class CoffeeMachine extends Colleague {
public CoffeeMachine(String name, Mediator mediator) {
super(name, mediator);
mediator.register(name, this);
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.getName());
}
public void startCoffee() {
System.out.println("制作咖啡");
}
public void finishCoffee() {
System.out.println("制作完成咖啡");
sendMessage(0);
}
}
public class Client {
public static void main(String[] args) {
//创建一个中介者对象
Mediator mediator = new ConcreteMediator();
//创建Alarm对象并加入到中介者对象的HashMap中
Alarm alarm = new Alarm("alarm", mediator);
//创建CoffeeMachine对象并加入到中介者对象的HashMap中
CoffeeMachine coffeeMachine = new CoffeeMachine("coffeeMachine", mediator);
//创建Curtains对象并加入到中介者对象的HashMap中
Curtains curtains = new Curtains("curtains", mediator);
//创建TV对象并加入到中介者对象的HashMap中
TV tv = new TV("TV", mediator);
//让闹钟发出消息
alarm.sendAlarm(0);
System.out.println("====");
alarm.sendAlarm(1);
System.out.println("====");
//让咖啡机发出消息
coffeeMachine.finishCoffee();
}
}
- 小结
多个类相互耦合,会形成网状结构, 使用中介者模式将网状结构分离为星型结构, 进行解耦
减少类间依赖,降低了耦合,符合迪米特原则
中介者承担了较多的责任,一旦中介者出现了问题,整个系统就会受到影响
如果设计不当,中介者对象本身变得过于复杂,这点在实际使用时,要特别注意
备忘录模式
- 案例
游戏角色状态恢复问题
游戏角色有攻击力和防御力,在大战Boss前保存自身的状态(攻击力和防御力),当大战Boss后攻击力和防御力下降,从备忘录对象恢复到大战前的状态。
- 传统方法
![](https://i-blog.csdnimg.cn/blog_migrate/e9ba9b2b0ada0671a098bb00a3174b0b.png)
- 分析
一个对象,就对应一个保存对象状态的对象, 这样当我们游戏的对象很多时,不利于管理,开销也很大.
传统的方式是简单地做备份,new出另外一个对象出来,再把需要备份的数据放到 这个新对象,但这就暴露了对象内部的细节
解决方案: => 备忘录模式
- 备忘录模式
解释:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。现实生活中的备忘录是用来记录某些要去做的事情, 或者是记录已经达成的共同意见的事情,以防忘记了。而在软件层面,备忘录模式有着相同的含义,备忘录对象主要用来记录一个对象的某种状态,或者某些数据,当要做回退时,可以从备忘录对象里获取原来的数据进行恢复操作。
- 代码实现
![](https://i-blog.csdnimg.cn/blog_migrate/9f6478f4f00af4a5bacc17ae250c1628.png)
对原理类图的说明-即 (备忘录模式的角色及职责)
Originator : 对象(需要保存状态的对象)
Memento : 备忘录对象,负责保存好记录,即Originator内部状态
Caretaker: 守护者对象,负责保存多个备忘录对象, 使用集合管理,提高效率
说明:如果希望保存多个originator对象的不同时间的状态,也可以,只需要 HashMap<String,集合>
![](https://i-blog.csdnimg.cn/blog_migrate/3219f79e4edcf6db073c81d055e0182d.png)
package com.yqj.pattern.memento;
import java.util.ArrayList;
import java.util.List;
//原始对象
class GameRole{
private int vit;
private int def;
public GameRole(int vit, int def) {
this.vit = vit;
this.def = def;
}
public Memento createMemento(){
return new Memento(vit,def);
}
public void recoverMenmento(Memento memento){
vit = memento.getVit();
def = memento.getDef();
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
@Override
public String toString() {
return "GameRole{" +
"vit=" + vit +
", def=" + def +
'}';
}
}
//备忘录对象
class Memento{
private int vit;
private int def;
public Memento(int vit, int def) {
this.vit = vit;
this.def = def;
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
class Caretaker{
//在集合中会有多个备忘录对象
private List<Memento> mementos = new ArrayList<>();
//将某个备忘录对象加入集合
public void add(Memento memento){
mementos.add(memento);
}
//获取第index个原始对象的备忘录对象(保存的状态)
public Memento get(int index){
return mementos.get(index);
}
}
public class Client {
public static void main(String[] args) {
GameRole gameRole = new GameRole(100,100);
Caretaker caretaker = new Caretaker();
caretaker.add(gameRole.createMemento());
gameRole.setVit(70);
gameRole.setDef(80);
caretaker.add(gameRole.createMemento());
gameRole.setVit(60);
gameRole.setDef(70);
caretaker.add(gameRole.createMemento());
System.out.println(gameRole);
//恢复状态1
gameRole.recoverMenmento(caretaker.get(1));
System.out.println(gameRole);
//恢复状态0
gameRole.recoverMenmento(caretaker.get(0));
System.out.println(gameRole);
}
}
- 小结
给用户提供了一种可以恢复状态的机制,可以使用户能够比较方便地回到某个历史的状态
实现了信息的封装,使得用户不需要关心状态的保存细节
如果类的成员变量过多,势必会占用比较大的资源,而且每一次保存都会消耗一定的内存, 这个需要注意
适用的应用场景:1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。 4、数据库的事务管理
为了节约内存,备忘录模式可以和原型模式配合使用