中介者模式学习和思考

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

     可以看出，中介者主要是通过中介对象来封装对象之间的关系，使之各个对象在不需要知道其他对象的具体信息情况下通过中介者对象来与之通信。同时通过引用中介者对象来减少系统对象之间关系，提高了对象的可复用和系统的可扩展性。

     但是就是因为中介者对象封装了对象之间的关联关系，导致中介者对象变得比较庞大，所承担的责任也比较多。它需要知道每个对象和他们之间的交互细节，如果它出问题，将会导致整个系统都会出问题。所以它比较容易应用也很容易误用。故当系统中出现了“多对多”交互复杂的关系群时，千万别急着使用中介者模式，你首先需要做的就是反思你的系统在设计上是不是合理。

二、实现：

类A和类B交互，例如类A需要修改类B的东西，同时类B需要修改类A的东西，如果直接修改也是可以的，但是这种强的耦合关系会带来维护上的困难，尤其是在后来系统扩展，多各类之间交互变得复杂的时候，越来越力不从心。可以考虑使用一个中介类Mediator，Mediator中有包含A和B，类A和类B都和Mediator交互，不直接交互，需要Mediator知道所有其他类的交互关系，Mediator是重要枢纽和瓶颈，一旦Mediator出问题了，全盘都可能会不稳定。所以，也是需要慎重使用的。

1. abstract class AbstractColleague {  
2.     protected int number;  
3.   
4.     public int getNumber() {  
5.         return number;  
6.     }  
7.   
8.     public void setNumber(int number){  
9.         this.number = number;  
10.     }  
11.     //注意这里的参数不再是同事类，而是一个中介者  
12.     public abstract void setNumber(int number, AbstractMediator am);  
13. }  
14.   
15. class ColleagueA extends AbstractColleague{  
16.   
17.     public void setNumber(int number, AbstractMediator am) {  
18.         this.number = number;  
19.         am.AaffectB();  
20.     }  
21. }  
22.   
23. class ColleagueB extends AbstractColleague{  
24.   
25.     @Override  
26.     public void setNumber(int number, AbstractMediator am) {  
27.         this.number = number;  
28.         am.BaffectA();  
29.     }  
30. }  
31.   
32. abstract class AbstractMediator {  
33.     protected AbstractColleague A;  
34.     protected AbstractColleague B;  
35.       
36.     public AbstractMediator(AbstractColleague a, AbstractColleague b) {  
37.         A = a;  
38.         B = b;  
39.     }  
40.   
41.     public abstract void AaffectB();  
42.       
43.     public abstract void BaffectA();  
44.   
45. }  
46. class Mediator extends AbstractMediator {  
47.   
48.     public Mediator(AbstractColleague a, AbstractColleague b) {  
49.         super(a, b);  
50.     }  
51.   
52.     //处理A对B的影响  
53.     public void AaffectB() {  
54.         int number = A.getNumber();  
55.         B.setNumber(number*100);  
56.     }  
57.   
58.     //处理B对A的影响  
59.     public void BaffectA() {  
60.         int number = B.getNumber();  
61.         A.setNumber(number/100);  
62.     }  
63. }  
64.   
65. public class Client {  
66.     public static void main(String[] args){  
67.         AbstractColleague collA = new ColleagueA();  
68.         AbstractColleague collB = new ColleagueB();  
69.           
70.         AbstractMediator am = new Mediator(collA, collB);  
71.           
72.         System.out.println("==========通过设置A影响B==========");  
73.         collA.setNumber(1000, am);  
74.         System.out.println("collA的number值为："+collA.getNumber());  
75.         System.out.println("collB的number值为A的10倍："+collB.getNumber());  
76.   
77.         System.out.println("==========通过设置B影响A==========");  
78.         collB.setNumber(1000, am);  
79.         System.out.println("collB的number值为："+collB.getNumber());  
80.         System.out.println("collA的number值为B的0.1倍："+collA.getNumber());  
81.           
82.     }  
83. } 

三、理解和思考：

1.中介者模式的功能

中介者的功能就是封装对象之间的交互。如果一个对象的操作会引起其他相关对象的变化，而这个对象又不希望自己来处理这些关系，那么就可以去找中介者，让它来处理这些麻烦的关系。

2.需要Mediator接口吗？

这一问题，首先得弄清楚接口用来干嘛的？接口是用来“封装隔离”的，Mediator接口用来封装中介者对象，使得中介者对象的客户对象跟具体的中介者实现对象分离开。如果只有一个中介者对象，预期中也没打算扩展，那就可以不定义Mediator接口。

3.同事关系

在标准的中介者模式中，将使用中介者对象来交互的那些对象称为同事类，这是要求这些类都要继承自相同的类或实现相同的接口，也就是说它们算是兄弟对象。

4.同事和中介者的关系

在模式中，当一个同事对象发生变化时，需要主动通知中介者，让中介者去处理和其他同事对象的相关交互。这就导致同事对象与中介对象必须有关系，同事对象需要知道中介对象，以便通知；中介对象需要知道同事对象，以便交互。所有它们的关系是相互依赖的。

5.如何实现同事和中介者的通信

一种方式是在Mediator接口中定义一个特殊的通知接口，作为一个通用的方法，让各个同事来调用这个方法。另一种就是采用观察者模式，把Mediator实现成为观察者，各个同事对象实现为Subject.这些同事对象发生改变时，就会通知Mediator。

6.广义中介者

在实际开发中，经常会简化中介者模式，来是开发变得简单，比如有如下的简化。

l 通常会去掉同事对象的父类，这样可以让任意的对象，只需要有交互，就可以成为同事

l 通常不定义Mediator接口，把具体的中介者对象实现成为单例

l 同事对象不再持有中介者，而是在需要的时候直接获取中介者对象并调用；中介者也不再持有同事对象，而是在具体处理方法里面去创建，或获取，或从数据传入需要的同事对象。

经过这样的简化、变形的情况称为广义中介者。

7.何时选用中介者模式

如果一组对象之间的通信方式比较复杂，导致相互依赖，结构混乱，可以采用中介者模式

如果一个对象引用很多对象，并且跟这些对象交互，导致难以服用该对象

8.模式本质

中介者模式的本质在于“封装交互”

中介者模式的目的，就是封装多个对象的交互，这些交互的多在中介者对象里实现。

只要是实现封装对象的交互，就可以使用中介者模式，不必拘泥于模式结构。

9.相关模式

中介者模式和外观模式

外观模式多用于封装一个子系统内部的多个模块，目的是向子系统外部提供简单易用的接口。

中介者模式是提供多个平等的同事对象之间交互关系的封装，一般是用在内部实现上。

中介者模式和观察者模式

这两个模式可以组合使用。

中介者模式可以组合使用观察者模式，来实现当同事对象发生改变时，通知中介对象，让中介对象去进行与其他相关对象的交互。

 最后是一个中介者模式的实例：打开电脑看电影

比如有如下的交互：

1.首先光驱读取光盘上的数据，然后告诉主板，它的状态已经改变了。

2.主板得到光驱的数据，将数据交给CPU进行分析处理。

3.CPU处理完，将数据分成了视频数据和音频数据，通知主板，已将处理好了。

4.主板得到数据，将数据交给显卡和声卡进行输出。