设计模式初探-中介者模式

中介者模式(MEDIATOR)，又称调停者模式，通过使用一个中介者对象来封装一系列的对象交互，属于对象行为型模式。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。现实生活中，到处充斥着中介者模式的身影。上到庄严的法院，下到为程序员带来福音的婚姻介绍所或交友平台，还有可恶的房产中介，都是中介者模式的体现。比如，你参加一个相亲活动，20多对男女如饥似渴地寻找着自己的另一半。如果不是一见钟情，你就需要了解20多个女生，不排除男生的话，就是40多个人的喜好，性格是否符合自己，这简直就是灾难！如果相亲活动举办地比较符合人情，有个官方的媒婆，她负责将20多对男女根据彼此的喜好，性格进行配对，这样就减少了相亲者之间的耦合关系，节省相亲者们的时间和精力，此乃中介者模式之妙用也。

一、使用场景

1、一组对象以定义良好但是复杂的方式进行通信，比如网络状的结构，这样产生的相互依赖关系结构混乱且难以理解。可以使用中介者模式对复杂依赖关系进行改造，以获取更好的灵活性。

2、一个对象引用其他很多对象并且直接与这些对象通信，导致该对象难以复用。中介者模式将对象的相互依赖关系转换为中介者和对象的依赖关系，使对象能够灵活复用。

3、想定制一个分布在多个类中的行为，而又不想生成太多的子类。

二、UML图

三、Java实现

[java] view plain copy

1. package study.patterns.mediator;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. /** 
6.  * 中介者模式将一个网状的系统结构变成一个以中介者对象为中心的星形结构， 
7.  * 在这个星型结构中，使用中介者对象与其他对象的一对多关系来取代原有对象之间的多对多关系。 
8.  * 中介者模式在事件驱动类软件中应用较为广泛，特别是基于GUI（Graphical User Interface， 
9.  * 图形用户界面）的应用软件，此外，在类与类之间存在错综复杂的关联关系的系统中， 
10.  * 中介者模式都能得到较好的应用。 
11.  * @author qbg 
12.  */  
13. public class MediatorPattern {  
14.     public static void main(String[] args) {  
15.         List<Person> ps = new ArrayList<Person>();  
16.         Person b0 = new Boy();  
17.         ps.add(b0);  
18.         Person b1 = new Boy();  
19.         ps.add(b1);  
20.         Person g0 = new Girl();  
21.         ps.add(g0);  
22.         Person g1 = new Girl();  
23.         ps.add(g1);  
24.         Mediator mediator = new ConcreteMediator(ps);  
25.         b0.setInterest("创业");  
26.         b0.setMediator(mediator);  
27.         b1.setInterest("挣钱");  
28.         b1.setMediator(mediator);  
29.         g0.setInterest("逛街");  
30.         g0.setMediator(mediator);  
31.         g1.setInterest("持家");  
32.         g1.setMediator(mediator);  
33.         b0.interest("持家");  
34.         System.out.println("==========男女有别===============");  
35.         g0.interest("挣钱");  
36.     }  
37. }  
38. /** 
39.  * 中介者抽象接口 
40.  */  
41. interface Mediator{  
42.     public void interestChanged(Person p);  
43. }  
44. /** 
45.  * 具体中介者，充当媒婆的角色。  
46.  */  
47. class ConcreteMediator implements Mediator{  
48.     private List<Person> miai; //相亲队伍  
49.       
50.     public ConcreteMediator(List<Person> ps){  
51.         this.miai = ps;  
52.     }  
53.       
54.     /** 
55.      * 相亲者兴趣改变时进行响应,重新匹配候选人. 
56.      * 封装同事对象之间的交互. 
57.      */  
58.     @Override  
59.     public void interestChanged(Person p) {  
60.         boolean succeed = false;  
61.         Person candidate = null;  
62.         for(Person person : miai){  
63.             //不是相亲者本身且兴趣相同则匹配成功!  
64.             if(person!=p && p.interest.equals(person.interest)){  
65.                 succeed = true;  
66.                 candidate = person;  
67.                 break;  
68.             }  
69.         }  
70.         p.update(succeed);  
71.         if(candidate!=null){  
72.             candidate.update(succeed);  
73.         }  
74.     }  
75.       
76. }  
77. /** 
78.  * 人，抽象同事类 
79.  */  
80. abstract class Person{  
81.     protected Mediator mediator;//中介者引用  
82.     protected String interest;//兴趣  
83.       
84.     public void setMediator(Mediator m){  
85.         this.mediator = m;  
86.     }  
87.     public void setInterest(String in){  
88.         this.interest = in;  
89.     }  
90.       
91.     public void interest(String interest){  
92.         this.interest = interest;  
93.         mediator.interestChanged(this);  
94.     }  
95.     public abstract void update(boolean succeed);  
96. }  
97. /** 
98.  * 男生，具体同事类 
99.  */  
100. class Boy extends Person{  
101.   
102.     @Override  
103.     public void update(boolean succeed) {  
104.         if(succeed){  
105.             System.out.println("相亲成功，大喝一顿！！！");  
106.         }else{  
107.             System.out.println("相亲失败，明天再战！！！");  
108.         }  
109.     }  
110. }  
111. /** 
112.  * 女生，具体同事类 
113.  */  
114. class Girl extends Person{  
115.   
116.     @Override  
117.     public void update(boolean succeed) {  
118.         if(succeed){  
119.             System.out.println("找到白马王子了，去KTV狂欢!");  
120.         }else{  
121.             System.out.println("黑驴都没找到，全是骡子，呜呜....");  
122.         }  
123.     }  
124. }  

运行结果：

[plain] view plain copy

1. 相亲成功，大喝一顿！！！  
2. 找到白马王子了，去KTV狂欢!  
3. ==========男女有别===============  
4. 找到白马王子了，去KTV狂欢!  
5. 相亲成功，大喝一顿！！！  

四、模式优缺点

优点：

1、减少了子类的生成。中介者Mediator将原本分布于多个对象间的行为集中在一起。改变这些行为只需生成Mediator的子类即可，这样各个同事类（Colleague类）可被重用。

2、将各Colleague解耦。Mediator有利于各Colleague间的松耦合，你可以独立的改变和复用各Colleague和Mediator类。

3、简化了对象协议。用Mediator和各Colleague间的一对多的交互来代替多对多的交互，使对象关系更易于理解，维护和扩展。

4、对对象如何协作进行了抽象。中介者模式很好的将使用者的注意力从对象各自本身的行为转移到它们之间的交互上。

5、使控制集中化。中介者模式将交互的复杂性变为中介者的复杂性。

缺点：

1、由于中介者模式将控制集中到中介者身上，可能会导致中介者过于复杂而难于维护。