java设计模式之中介者模式Mediator

1、 意图

用一个中介者对象来封装一系列的对象交互。中介者使其各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立改变它们之间的交互。

2、 适用性

• 一组对象以定义好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
• 一个对象引用其他很对对象并且直接与这些对象通信，导致难以复用该对象。
• 想制定一个分布在多个类中的行为，而又不想生成太多的子类。

3、 结构

4、 参与者

Mediatord（中介者）

                            ——中介者定义一个接口用于与各同事（Colleague）对象通信。

ConcreteMediator（具体中介者）

                            ——了解中介者通过协调各同事对象实现协作行为。

                           ——了解并维护它的各个同事。

ColleagueClass（同事类，包括其子类）

                           ——每一个同事类都知道它的中介者对象。

                           ——每一个同事类对象在需与其他同事通信的时候，与它的中介者通信。

5、 协作

同事向一个中介者对象发送和接收请求。中介者在各同事间适当地转发请求以实现协作行为。

6、 效果

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

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

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

4）  它对对象如何协作进行了抽象；将中介作为一个独立的概念并将其封装在一个对象中，使你将注意力从对象各自本身的行为转移到它们之间的交互上来。这有助于弄清楚一个系统中的对象是如何交互的。

5）  它使控制集中化；中介者模式将交互的复杂性变为中介者的复杂性。因为中介者封装了协议，它可能变得比任一个Colleague都复杂。这可能使得中介者自身成为一个难以维护的庞然大物。

7、 实现

1）   忽略抽象的Mediator类；当各Colleague仅与一个Mediator一起工作时，没有必要定义一个抽象的Mediator类。Mediator类提供的抽象耦合已经使各Colleague可与不同的Mediator子类一起工作，反之亦然。

2）  Colleague——Mediator通信；当一个感兴趣的事件发生时，Colleague必须与其Mediator通信。一种实现方法是Observer模式，将Mediator实现为一个Observer，各Colleague作为Subset，一旦其状态改变就发送通知给Mediator；一种方法是在Mediator中定义一个特殊的通知接口，各Colleague在通信时直接调用该接口。

8、 代码示例

Mediatord

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. /** 
4.  * 中介者，定义各个同事对象通信的接口 
5.  */  
6. public interface Mediator {  
7.   
8.     /** 
9.      * 同事对象自身改变的时候来通知中介者的方法 让中介者去负责相应的与其他同事对象的交互 
10.      *  
11.      * @param colleague 
12.      *            同事对象自身，好让中介者对象通过对象实例去获得同事对象的状态 
13.      */  
14.     public void changed(Colleague colleague);  
15. }  

ConcreteMediator

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. /** 
4.  * 具体的中介者实现 
5.  */  
6. public class ConcreteMediator implements Mediator {  
7.   
8.     /** 
9.      * 持有并维护同事A 
10.      */  
11.     private ConcreteColleagueA colleagueA;  
12.     /** 
13.      * 持有并维护同事B 
14.      */  
15.     private ConcreteColleagueB colleagueB;  
16.   
17.     /** 
18.      * 设置中介者需要了解并维护的同事A对象 
19.      * @param colleagueA 
20.      */  
21.     public void setColleagueA(ConcreteColleagueA colleagueA) {  
22.         this.colleagueA = colleagueA;  
23.     }  
24.   
25.     /** 
26.      * 设置中介者需要了解并维护的同事B对象 
27.      * @param colleagueB 
28.      */  
29.     public void setColleagueB(ConcreteColleagueB colleagueB) {  
30.         this.colleagueB = colleagueB;  
31.     }  
32.   
33.     @Override  
34.     public void changed(Colleague colleague) {  
35.         System.out.println(colleague);  
36.     }  
37.   
38. }  

 Colleague Class

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. /**    
4. * 同事类的抽象父类        
5. */  
6. public abstract class Colleague {  
7.   
8.     /** 
9.      * 持有中介者对象，每一个同事类都知道它的中介者对象 
10.      */  
11.     private Mediator mediator;  
12.   
13.     /** 
14.      * 构造者方法，传入中介者对象 
15.      * @param mediator 
16.      */  
17.     public Colleague(Mediator mediator) {  
18.         this.mediator = mediator;  
19.     }  
20.   
21.     /** 
22.      * 获得当前同事类对应的中介者对象 
23.      * @return 
24.      */  
25.     public Mediator getMediator() {  
26.         return mediator;  
27.     }  
28.       
29.       
30.       
31. }  

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. /**    
4. *  具体的同事类A       
5. */  
6. public class ConcreteColleagueA extends Colleague {  
7.   
8.     public ConcreteColleagueA(Mediator mediator) {  
9.         super(mediator);  
10.     }  
11.       
12.     public void someOperation(){  
13.         //在需要跟其他同事通信的时候，通知中介者对象  
14.         getMediator().changed(this);  
15.     }  
16.   
17. }  

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. public class ConcreteColleagueB extends Colleague {  
4.   
5.     public ConcreteColleagueB(Mediator mediator) {  
6.         super(mediator);  
7.     }  
8.       
9.     public void someOperation(){  
10.         //在需要跟其他同事通信的时候，通知中介者对象  
11.         getMediator().changed(this);  
12.     }  
13.   
14. }  

Client

[java]  view plain copy

1. package com.examples.pattern.mediator;  
2.   
3. public class Client {  
4.   
5.     public static void main(String[] args) {  
6.         ConcreteMediator mediator = new ConcreteMediator();  
7.         ConcreteColleagueA ca = new ConcreteColleagueA(mediator);  
8.         ConcreteColleagueB cb = new ConcreteColleagueB(mediator);  
9.           
10.         mediator.setColleagueA(ca);  
11.         mediator.setColleagueB(cb);  
12.           
13.         ca.someOperation();  
14.         cb.someOperation();  
15.           
16.           
17.     }  
18.   
19. }  

9、 相关模式

Façade与中介者的不同之处在于它是对一个对象子系统进行抽象，从而提供了一个更方便的接口。它的协议是单向的，即Façade对象对这个子系统类提出请求，但反之则不行。相反，Mediator提供了各Colleague对象不支持或不能支持的协作行为，而且协议是多向的。

Colleague可使用Observer模式与Mediator通信。

10、 广义中介者

在我们的通常使用中，经常会简化中介者模式，来使开发变得简单，有如下变化：

• 通常会去掉同事对象的父类，这样可以让任意的对象，只要需要相互交互，就可以成为同事。
• 通常不定义Mediator接口，把具体的中介者对象实现成单例。
•  同事对象不再持有中介者，而是在需要的时候直接获取中介者对象并调用；中介者也不再持有同事对象，而是在具体处理方法里面去创建，或者获取，或者从参数传入需要的同事对象。