中介者设计模式
中介者设计模式
一、中介者设计模式
1、介绍
中介者模式：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互
中介者模式属于行为型模式，使代码易于维护
比如MVC模式，C（controller控制器）是M（Model模型）和V（View视图）的中介者，在前后端交互起到中间人的作用
2、UML
Mediator：抽象中介者，定义了同事对象到中介者对象的接口
ConcreteMediator：具体的中介者对象，实现了抽象方法，它需要知道所有的具体的同事类，即以一个集合来管理HashMap，并接收某个同事对象消息，完成相应的任务
Collague：抽象同事类
ConcreteCollague：具体的同事类，会有很多，每个同时类只知道自己的行为，而不了解其他同事类的行为，但他们都依赖中介者对象
3、中介者模式注意事项和细节
- 多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦
- 减少类之间的依赖，降低耦合，符合迪米特原则
- 中介者承担了较多的责任，一旦中介者出现问题，整个系统都会受到影响
- 中介者本身过于复杂
二、案例
1、介绍
智能家庭设备：闹钟、咖啡机、电视机、窗帘
各个设备协同工作，自动完成看电视的准备工作和后续工作：
闹钟响起->启动咖啡机开始做咖啡->降下窗帘->电视机开始播放—>关闭咖啡机喝咖啡->电视机关闭->窗帘拉起
2、UML
3、代码
/**
* @description: 同事抽象类
* @author: dashu
* @create: 10:02
*/
public abstract class Colleague {
/**
* 中介者
*/
private Mediator mediator;
/**
* 名称
*/
public String name;
/**
* 构造方法
* @param mediator 中介者
* @param name 名称
*/
public Colleague(Mediator mediator,String name){
this.mediator = mediator;
this.name = name;
}
/**
* 获取中介者
* @return
*/
public Mediator getMediator() {
return this.mediator;
}
/**
* 发送消息
*
* @param stateChange
*/
public abstract void sendMessage(int stateChange);
}
/**
* @description: 闹钟
* @author: dashu
* @create: 10:06
*/
public class Alarm extends Colleague {
/**
* 构造方法
*
* @param mediator 中介者
* @param name 名称
*/
public Alarm(Mediator mediator, String name) {
super(mediator, name);
mediator.register(name, this);
}
/**
* 发送消息
*
* @param stateChange
*/
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.name);
}
}
/**
* @description: 咖啡机
* @author: dashu
* @create: 10:09
*/
public class CoffeeMachine extends Colleague {
/**
* 构造方法
*
* @param mediator 中介者
* @param name 名称
*/
public CoffeeMachine(Mediator mediator, String name) {
super(mediator, name);
mediator.register(name, this);
}
/**
* 发送消息
*
* @param stateChange
*/
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.name);
}
/**
* 启动咖啡机
*/
public void startCoffee() {
System.out.println("启动咖啡机!");
}
/**
* 喝咖啡
*/
public void finishCoffee() {
System.out.println("5分钟后!");
stopCoffee();
System.out.println("喝咖啡!");
}
/**
* 关闭咖啡机
*/
public void stopCoffee() {
System.out.println("关闭咖啡机!");
}
}
/**
* @description: 窗帘
* @author: dashu
* @create: 10:59
*/
public class Curtains extends Colleague {
/**
* 构造方法
*
* @param mediator 中介者
* @param name 名称
*/
public Curtains(Mediator mediator, String name) {
super(mediator, name);
mediator.register(name, this);
}
/**
* 发送消息
*
* @param stateChange
*/
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.name);
}
/**
* 拉下窗帘
*/
public void downCurtains() {
System.out.println("拉下窗帘！");
}
/**
* 升起窗帘
*/
public void upCurtains() {
System.out.println("升起窗帘！");
}
}
/**
* @description: 电视
* @author: dashu
* @create: 10:55
*/
public class TV extends Colleague {
/**
* 构造方法
*
* @param mediator 中介者
* @param name 名称
*/
public TV(Mediator mediator, String name) {
super(mediator, name);
mediator.register(name, this);
}
/**
* 发送消息
*
* @param stateChange
*/
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange, this.name);
}
/**
* 打开电视
*/
public void startTV() {
System.out.println("打开电视!");
}
/**
* 关闭电视
*/
public void stopTV() {
System.out.println("关闭电视!");
}
}
/**
* @description: 中介者
* @author: dashu
* @create: 10:02
*/
public abstract class Mediator {
/**
* 注册
*
* @param colleagueName
* @param colleague
*/
public abstract void register(String colleagueName, Colleague colleague);
/**
* 获取消息
*
* @param stateChange
* @param colleagueName
*/
public abstract void getMessage(int stateChange, String colleagueName);
}
/**
* @description: 具体的中介者
* @author: dashu
* @create: 10:14
*/
public class ConcreteMediator extends Mediator {
private HashMap<String, Colleague> colleaguesMap;
private HashMap<String, String> interMap;
public ConcreteMediator() {
colleaguesMap = new HashMap<>();
interMap = new HashMap<>();
}
/**
* 注册
*
* @param colleagueName
* @param colleague
*/
@Override
public void register(String colleagueName, Colleague colleague) {
colleaguesMap.put(colleagueName, colleague);
if (colleague instanceof Alarm) {
interMap.put("Alarm", colleagueName);
} else if (colleague instanceof CoffeeMachine) {
interMap.put("CoffeeMachine", colleagueName);
} else if (colleague instanceof TV) {
interMap.put("TV", colleagueName);
} else if (colleague instanceof Curtains) {
interMap.put("Curtains", colleagueName);
}
}
/**
* 获取消息
*
* @param stateChange
* @param colleagueName
*/
@Override
public void getMessage(int stateChange, String colleagueName) {
if (colleaguesMap.get(colleagueName) instanceof Alarm) {
if (stateChange == 0) {
((CoffeeMachine) (colleaguesMap.get(interMap.get("CoffeeMachine")))).startCoffee();
((Curtains) (colleaguesMap.get(interMap.get("Curtains")))).downCurtains();
((TV) (colleaguesMap.get(interMap.get("TV")))).startTV();
} else if (stateChange == 1) {
((TV) (colleaguesMap.get(interMap.get("TV")))).stopTV();
((Curtains) (colleaguesMap.get(interMap.get("Curtains")))).upCurtains();
}
} else if (colleaguesMap.get(colleagueName) instanceof CoffeeMachine) {
((CoffeeMachine) (colleaguesMap.get(interMap.get("CoffeeMachine")))).finishCoffee();
} else if (colleaguesMap.get(colleagueName) instanceof TV) {
} else if (colleaguesMap.get(colleagueName) instanceof Curtains) {
}
}
}
/**
* @description: 客户端
* @author: dashu
* @create: 10:01
*/
public class Client {
/**
*
* 智能家庭设备：闹钟、咖啡机、电视机、窗帘
*
* 各个设备协同工作，自动完成看电视的准备工作和后续工作：
* 闹钟响起->启动咖啡机开始做咖啡->降下窗帘->电视机开始播放—>关闭咖啡机喝咖啡->电视机关闭->窗帘拉起
*
*/
public static void main(String[] args) {
Mediator mediator = new ConcreteMediator();
Colleague alarm = new Alarm(mediator,"闹钟");
Colleague coffeeMachine = new CoffeeMachine(mediator,"咖啡机");
Colleague tv = new TV(mediator,"电视机");
Colleague curtains = new Curtains(mediator,"窗帘");
alarm.sendMessage(0);
coffeeMachine.sendMessage(0);
alarm.sendMessage(1);
}
}