中介者模式
中介者模式案例引入
要求
[*]1.智能家庭包括设备，闹钟，咖啡机，窗帘等。
[*]2.主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为，闹钟响起-> 咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。
传统方式实现案例
有闹钟类(Alarm)，电视类(TV)，窗帘类(Curtains)，咖啡机(Coffee Machine)，闹钟发消息给咖啡机，咖啡机发消息给窗帘，窗帘发消息给电视，来实现要求中的流程。
中介者模式和外观模式的区别，内部子系统是独立的。
传统方式问题分析
[*]1.当各电器对象有多种状态改变时，相互之间的调用关系会比较复杂。
[*]2.各个电器对象间彼此联系，相互依赖，不利于松耦合。
[*]3.各个电器对象之间，所传递的消息多，很容易混乱。
[*]4.当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性，扩展性都不理想 -> 考虑使用中介者模式。
中介者模式基本介绍
[*]1.中介者模式(Mediator Pattern)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示地相互引用，从而使其松耦合，而且可以独立地改变子系统之间的交互。
[*]2.中介者模式属于行为型模式，使代码易于维护。
[*]3.比如MVC模式，C(Controller 控制器)是M(Model 模型)和V(View 视图)的中介者，在前后端交互中起到了中间人的作用。
原理类图
https://img2023.cnblogs.com/blog/2883613/202310/2883613-20231007233016175-2022160778.png
角色分析
[*]1.Mediator是抽象的中介者类。
[*]2.Colleague是抽象的同事类，也可以看作是抽象的子系统的类。
[*]3.ConcreteMediator具体的中介者对象，实现抽象方法，他需要知道所有的具体子系统类，并以一个HashMap集合的方式来管理所有的同事对象消息，完成相应的操作。
[*]4.ConcreteColleague具体的同事类(子系统类)，会有很多，每个同事(子系统)只知道自己的行为，而不了解其他同事类(子系统)的行为(方法) 但是这些对象都依赖中介者对象。
中介者实现案例代码
/**
* @author 长名06
* @version 1.0
* 中介者抽象类
*/
public abstract class Mediator {
public abstract void register(String colleagueName,Colleague colleague);
public abstract void getMessage(int stateChange,String colleagueName);
public abstract void sendMessage();
}
/**
* @author 长名06
* @version 1.0
* 具体的抽象者类
*/
public class ConcreteMediator extends Mediator{
//hashMap集合，存储所有的子系统对象
private HashMap<String,Colleague> colleagueMap;
private HashMap<String,String> interMap;
public ConcreteMediator(){
colleagueMap = new HashMap<String,Colleague>();
interMap = new HashMap<String,String>();
}
@Override
public void register(String colleagueName, Colleague colleague) {
colleagueMap.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);
}
/**
* 具体中介者的核心方法
* @param stateChange
* @param colleagueName
*/
@Override
public void getMessage(int stateChange, String colleagueName) {
if(colleagueMap.get(colleagueName) instanceof Alarm){
if(stateChange == 0){
((CoffeeMachine) colleagueMap.get(interMap.get("CoffeeMachine"))).startCoffee();
((TV)colleagueMap.get(interMap.get("TV"))).startTV();
}else if(stateChange == 1){
((TV)colleagueMap.get(interMap.get("TV"))).stopTV();
}
} else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
//TV发消息，代码没写全，理解这个思想即可
}else if(colleagueMap.get(colleagueName) instanceof TV){
}
}
@Override
public void sendMessage() {
}
}
/**
* @author 长名06
* @version 1.0
* 子系统(同事)抽象类
*/
public abstract class Colleague {
//持有中介者对象
private Mediator mediator;
//子系统name属性
public String name;
public Colleague(Mediator mediator,String name){
this.mediator = mediator;
this.name = name;
}
public Mediator getMediator(){
return this.mediator;
}
public abstract void sendMessage(int stateChange);
}
public class Alarm extends Colleague{
public Alarm(Mediator mediator,String name){
super(mediator,name);
mediator.register(name,this);
}
public void sendAlarm(int stateChange){
sendMessage(stateChange);
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange,this.name);
}
}
public class CoffeeMachine extends Colleague{
public CoffeeMachine(Mediator mediator,String name){
super(mediator,name);
mediator.register(name,this);
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange,this.name);
}
public void startCoffee(){
System.out.println("开始做咖啡");
}
public void finishCoffee(){
System.out.println("五分钟后");
System.out.println("咖啡制作完成");
sendMessage(0);
}
}
public class TV extends Colleague{
public TV(Mediator mediator,String name){
super(mediator,name);
mediator.register(name,this);
}
public void startTV(){
System.out.println("开启电视");
}
public void stopTV(){
System.out.println("关闭电视");
}
@Override
public void sendMessage(int stateChange) {
this.getMediator().getMessage(stateChange,this.name);
}
}
public class Client {
public static void main(String[] args) {
ConcreteMediator concreteMediator = new ConcreteMediator();
//创建Alarm对象，并加入到 ConcreteMediator的hashMap中
Alarm alarm = new Alarm(concreteMediator, "Alarm");
CoffeeMachine coffeeMachine = new CoffeeMachine(concreteMediator,"CoffeeMachine");
TV tV = new TV(concreteMediator, "TV");
alarm.sendMessage(0);
coffeeMachine.finishCoffee();
alarm.sendAlarm(1);
}
}注意事项和细节
[*]1.多个类，相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦。
[*]2.减少类间依赖，降低了耦合，符合迪米特法则。
[*]3.中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响。
[*]4.如果设计不当，中介者对象本身变得过于复杂，这点在使用时，需格外注意。
只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]