中介者模式

中介者模式

案例引入

要求

• 1.智能家庭包括设备，闹钟，咖啡机，窗帘等。
  
• 2.主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为，闹钟响起-> 咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。
  

传统方式实现案例

有闹钟类(Alarm)，电视类(TV)，窗帘类(Curtains)，咖啡机(Coffee Machine)，闹钟发消息给咖啡机，咖啡机发消息给窗帘，窗帘发消息给电视，来实现要求中的流程。
中介者模式和外观模式的区别，内部子系统是独立的。
传统方式问题分析

• 1.当各电器对象有多种状态改变时，相互之间的调用关系会比较复杂。
  
• 2.各个电器对象间彼此联系，相互依赖，不利于松耦合。
  
• 3.各个电器对象之间，所传递的消息多，很容易混乱。
  
• 4.当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性，扩展性都不理想 -> 考虑使用中介者模式。
  

中介者模式基本介绍

• 1.中介者模式(Mediator Pattern)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示地相互引用，从而使其松耦合，而且可以独立地改变子系统之间的交互。
  
• 2.中介者模式属于行为型模式，使代码易于维护。
  
• 3.比如MVC模式，C(Controller 控制器)是M(Model 模型)和V(View 视图)的中介者，在前后端交互中起到了中间人的作用。
  

原理类图


角色分析

• 1.Mediator是抽象的中介者类。
  
• 2.Colleague是抽象的同事类，也可以看作是抽象的子系统的类。
  
• 3.ConcreteMediator具体的中介者对象，实现抽象方法，他需要知道所有的具体子系统类，并以一个HashMap集合的方式来管理所有的同事对象消息，完成相应的操作。
  
• 4.ConcreteColleague具体的同事类(子系统类)，会有很多，每个同事(子系统)只知道自己的行为，而不了解其他同事类(子系统)的行为(方法) 但是这些对象都依赖中介者对象。
  

中介者实现案例代码

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 中介者抽象类
5. */
6. public abstract class Mediator {
7.     public abstract void register(String colleagueName,Colleague colleague);
9.     public abstract void getMessage(int stateChange,String colleagueName);
11.     public abstract void sendMessage();
13. }
14. /**
15. * @author 长名06
16. * @version 1.0
17. * 具体的抽象者类
18. */
19. public class ConcreteMediator extends Mediator{
21.     //hashMap集合，存储所有的子系统对象
22.     private HashMap<String,Colleague> colleagueMap;
23.     private HashMap<String,String> interMap;
25.     public ConcreteMediator(){
26.         colleagueMap = new HashMap<String,Colleague>();
27.         interMap = new HashMap<String,String>();
28.     }
30.     @Override
31.     public void register(String colleagueName, Colleague colleague) {
32.         colleagueMap.put(colleagueName,colleague);
34.         if(colleague instanceof Alarm)
35.             interMap.put("Alarm",colleagueName);
36.         else if(colleague instanceof CoffeeMachine)
37.             interMap.put("CoffeeMachine",colleagueName);
38.         else if(colleague instanceof TV)
39.             interMap.put("TV",colleagueName);
40.     }
42.     /**
43.      * 具体中介者的核心方法
44.      * @param stateChange
45.      * @param colleagueName
46.      */
47.     @Override
48.     public void getMessage(int stateChange, String colleagueName) {
49.         if(colleagueMap.get(colleagueName) instanceof Alarm){
50.             if(stateChange == 0){
51.                 ((CoffeeMachine) colleagueMap.get(interMap.get("CoffeeMachine"))).startCoffee();
52.                 ((TV)colleagueMap.get(interMap.get("TV"))).startTV();
53.             }else if(stateChange == 1){
54.                 ((TV)colleagueMap.get(interMap.get("TV"))).stopTV();
55.             }
56.         } else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
57.             //TV发消息，代码没写全，理解这个思想即可
58.         }else if(colleagueMap.get(colleagueName) instanceof TV){
60.         }
61.     }
63.     @Override
64.     public void sendMessage() {
66.     }
67. }
69. /**
70. * @author 长名06
71. * @version 1.0
72. * 子系统(同事)抽象类
73. */
74. public abstract class Colleague {
75.     //持有中介者对象
76.     private Mediator mediator;
77.     //子系统name属性
78.     public String name;
80.     public Colleague(Mediator mediator,String name){
81.         this.mediator = mediator;
82.         this.name = name;
83.     }
85.     public Mediator getMediator(){
86.         return this.mediator;
87.     }
89.     public abstract void sendMessage(int stateChange);
91. }
92. public class Alarm extends Colleague{
94.     public Alarm(Mediator mediator,String name){
95.         super(mediator,name);
96.         mediator.register(name,this);
97.     }
99.     public void sendAlarm(int stateChange){
100.         sendMessage(stateChange);
101.     }
103.     @Override
104.     public void sendMessage(int stateChange) {
105.         this.getMediator().getMessage(stateChange,this.name);
106.     }
107. }
108. public class CoffeeMachine extends Colleague{
110.     public CoffeeMachine(Mediator mediator,String name){
111.         super(mediator,name);
112.         mediator.register(name,this);
113.     }
115.     @Override
116.     public void sendMessage(int stateChange) {
117.         this.getMediator().getMessage(stateChange,this.name);
118.     }
120.     public void startCoffee(){
121.         System.out.println("开始做咖啡");
122.     }
124.     public void finishCoffee(){
125.         System.out.println("五分钟后");
126.         System.out.println("咖啡制作完成");
127.         sendMessage(0);
128.     }
129. }
130. public class TV extends Colleague{
132.     public TV(Mediator mediator,String name){
133.         super(mediator,name);
134.         mediator.register(name,this);
135.     }
137.     public void startTV(){
138.         System.out.println("开启电视");
139.     }
141.     public void stopTV(){
142.         System.out.println("关闭电视");
143.     }
145.     @Override
146.     public void sendMessage(int stateChange) {
147.         this.getMediator().getMessage(stateChange,this.name);
148.     }
149. }
150. public class Client {
151.     public static void main(String[] args) {
152.         ConcreteMediator concreteMediator = new ConcreteMediator();
154.         //创建Alarm对象，并加入到 ConcreteMediator的hashMap中
155.         Alarm alarm = new Alarm(concreteMediator, "Alarm");
156.         CoffeeMachine coffeeMachine = new CoffeeMachine(concreteMediator,"CoffeeMachine");
157.         TV tV = new TV(concreteMediator, "TV");
159.         alarm.sendMessage(0);
160.         coffeeMachine.finishCoffee();
161.         alarm.sendAlarm(1);
162.     }
163. }

复制代码

注意事项和细节

• 1.多个类，相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦。
  
• 2.减少类间依赖，降低了耦合，符合迪米特法则。
  
• 3.中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响。
  
• 4.如果设计不当，中介者对象本身变得过于复杂，这点在使用时，需格外注意。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！