qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

跟屌丝大哥一起学习设计模式---中介者模式

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

举例:在一个公司里面,有很多部门、员工(我们统称他们互相为Colleague“同事),为了完成一定的任务,“同事”之间肯定有许多需要互相配合、交流的过程。如果由各个“同事”频繁地到处去与自己有关的“同事”沟通,这样肯定会形成一个多对多的杂乱的联系网络而造成工作效率低下。

此时就需要一位专门的“中介者”给各个“同事”分配任务,以及统一跟进大家的进度并在“同事”之间实时地进行交互,保证“同事”之间必须的沟通交流。很明显我们知道此时的“中介者”担任了沟通“同事”彼此之间的重要角色了,“中介者”使得每个“同事”都变成一对一的联系方式,减轻了每个“同事”的负担,增强工作效率。

大概理清上面简单例子中的意图之后,给出中介者模式适用场景:
1、一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
2、一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
3、想定制一个分布在多个类中的行为,而又不想生成太多的子类。
 
其实,中介者模式又被称为“调停者”模式,我们可以理解为一群小孩子(同事)吵架了,这时就很需要一位大人(调停者)过来处理好小孩子们的关系,以免发生不必要的冲突。“中介者”和“调停者”只不过是同一个英语单词“Mediator”的不同翻译罢了。反正最最重要的是:中介者就是一个处于众多对象,并恰当地处理众多对象之间相互之间的联系的角色。
下面给出具体的代码例子,对比通用类图增加了AbstractColleague抽象同事类和AbstractMediator抽象中介者,另外就是两个具体同事类和一个具体中介者,代码中有较多注释,相应类图也不给出了,应该不难理解的:

  同事类族:
  1. //抽象同事类  
  2. abstract class AbstractColleague {  
  3.     protected AbstractMediator mediator;  
  4.       
  5.     /**既然有中介者,那么每个具体同事必然要与中介者有联系,  
  6.      * 否则就没必要存在于 这个系统当中,这里的构造函数相当  
  7.      * 于向该系统中注册一个中介者,以取得联系  
  8.      */ 
  9.     public AbstractColleague(AbstractMediator mediator) {  
  10.         this.mediator = mediator;  
  11.     }  
  12.       
  13.     // 在抽象同事类中添加用于与中介者取得联系(即注册)的方法  
  14.     public void setMediator(AbstractMediator mediator) {  
  15.         this.mediator = mediator;  
  16.     }  
  17. }  
  18.  
  19. //具体同事A  
  20. class ColleagueA extends AbstractColleague {  
  21.       
  22.     //每个具体同事都通过父类构造函数与中介者取得联系  
  23.     public ColleagueA(AbstractMediator mediator) {  
  24.         super(mediator);  
  25.     }  
  26.       
  27.     //每个具体同事必然有自己分内的事,没必要与外界相关联  
  28.     public void self() {  
  29.         System.out.println("同事A --> 做好自己分内的事情 ...");  
  30.     }  
  31.       
  32.     //每个具体同事总有需要与外界交互的操作,通过中介者来处理这些逻辑并安排工作  
  33.     public void out() {  
  34.         System.out.println("同事A --> 请求同事B做好分内工作 ...");  
  35.         super.mediator.execute("ColleagueB""self");  
  36.     }  
  37. }  
  38.  
  39. //具体同事B  
  40. class ColleagueB extends AbstractColleague {  
  41.       
  42.     public ColleagueB(AbstractMediator mediator) {  
  43.         super(mediator);  
  44.     }  
  45.       
  46.     public void self() {  
  47.         System.out.println("同事B --> 做好自己分内的事情 ...");  
  48.     }  
  49.       
  50.     public void out() {  
  51.         System.out.println("同事B --> 请求同事A做好分内工作  ...");  
  52.         super.mediator.execute("ColleagueA""self");  
  53.     }  
中介者类族:
  1. //抽象中介者  
  2. abstract class AbstractMediator {  
  3.       
  4.     //中介者肯定需要保持有若干同事的联系方式  
  5.     protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();  
  6.       
  7.     //中介者可以动态地与某个同事建立联系  
  8.     public void addColleague(String name, AbstractColleague c) {  
  9.         this.colleagues.put(name, c);  
  10.     }     
  11.       
  12.     //中介者也可以动态地撤销与某个同事的联系  
  13.     public void deleteColleague(String name) {  
  14.         this.colleagues.remove(name);  
  15.     }  
  16.       
  17.     //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作  
  18.     public abstract void execute(String name, String method);   
  19. }  
  20.  
  21. //具体中介者  
  22. class Mediator extends AbstractMediator{  
  23.       
  24.     //中介者最重要的功能,来回奔波与各个同事之间  
  25.     public void execute(String name, String method) {  
  26.           
  27.         if("self".equals(method)){  //各自做好分内事  
  28.             if("ColleagueA".equals(name)) {  
  29.                 ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  
  30.                 colleague.self();  
  31.             }else {  
  32.                 ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  
  33.                 colleague.self();  
  34.             }  
  35.         }else { //与其他同事合作  
  36.             if("ColleagueA".equals(name)) {  
  37.                 ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  
  38.                 colleague.out();  
  39.             }else {  
  40.                 ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  
  41.                 colleague.out();  
  42.             }  
  43.         }  
  44.     }  
  1. 测试类  
  2. public class Client {  
  3.     public static void main(String[] args) {  
  4.           
  5.         //创建一个中介者  
  6.         AbstractMediator mediator = new Mediator();  
  7.           
  8.         //创建两个同事  
  9.         ColleagueA colleagueA = new ColleagueA(mediator);  
  10.         ColleagueB colleagueB = new ColleagueB(mediator);  
  11.           
  12.         //中介者分别与每个同事建立联系  
  13.         mediator.addColleague("ColleagueA", colleagueA);  
  14.         mediator.addColleague("ColleagueB", colleagueB);  
  15.           
  16.         //同事们开始工作  
  17.         colleagueA.self();  
  18.         colleagueA.out();  
  19.         System.out.println("======================合作愉快,任务完成!\n");  
  20.           
  21.         colleagueB.self();  
  22.         colleagueB.out();  
  23.         System.out.println("======================合作愉快,任务完成!");  
  24.     }  
测试结果: 
  1. 同事A --> 做好自己分内的事情 ...  
  2. 同事A --> 请求同事B做好分内工作 ...  
  3. 同事B --> 做好自己分内的事情 ...  
  4. ======================合作愉快,任务完成!  
  5.  
  6. 同事B --> 做好自己分内的事情 ...  
  7. 同事B --> 请求同事A做好分内工作  ...  
  8. 同事A --> 做好自己分内的事情 ...  
  9. ======================合作愉快,任务完成!  
 
虽然以上代码中只有两个具体同事类,并且测试类中也只是创建了两个同事,但是这些我们都可以根据中介者模式的宗旨进行适当地扩展,即增加具体同事类,然后中介者就得担负更加重的任务了。为啥?我们看到上面具体中介者类Mediator中的execute()方法中现在就有一堆冗长的判断代码了。虽然可以把它分解并增加到Mediator类中的其它private方法中,但是具体的业务逻辑是少不了的。
 
所以,在解耦同事类之间的联系的同时,中介者自身也不免任务过重,因为几乎所有的业务逻辑都交代到中介者身上了,可谓是“万众期待”的一个角色了。这就是中介者模式的不足之处了 。 

此外,上面这个代码例子是相当理想的了,有时候我们根本抽取不了“同事”之间的共性来形成一个AbstractColleague抽象同事类,这也大大增加了中介者模式的使用难度。 

修改

由于上面代码实现中存在 benjielin 前辈提出的“双向关联暴露在App中”的不足之处,根据给出的改进方法2,修改上面代码,如下:

修改后的同事类族:

  1. //抽象同事类  
  2. abstract class AbstractColleague {  
  3.     protected AbstractMediator mediator;      
  4.       
  5.     //舍去在构造函数中建立起与中介者的联系  
  6. //  public AbstractColleague(AbstractMediator mediator) {  
  7. //      this.mediator = mediator;  
  8. //  }  
  9.       
  10.     // 在抽象同事类中添加用于与中介者取得联系(即注册)的方法  
  11.     public void setMediator(AbstractMediator mediator) {  
  12.         this.mediator = mediator;  
  13.     }  
  14. }  
  15.  
  16. //具体同事A  
  17. class ColleagueA extends AbstractColleague {  
  18.       
  19.     //舍去在构造函数中建立起与中介者的联系  
  20. //  public ColleagueA(AbstractMediator mediator) {  
  21. //      super(mediator);  
  22. //  }  
  23.       
  24.     //每个具体同事必然有自己分内的事,没必要与外界相关联  
  25.     public void self() {  
  26.         System.out.println("同事A --> 做好自己分内的事情 ...");  
  27.     }  
  28.       
  29.     //每个具体同事总有需要与外界交互的操作,通过中介者来处理这些逻辑并安排工作  
  30.     public void out() {  
  31.         System.out.println("同事A --> 请求同事B做好分内工作 ...");  
  32.         super.mediator.execute("ColleagueB""self");  
  33.     }  
  34. }  
  35.  
  36. //具体同事B  
  37. class ColleagueB extends AbstractColleague {  
  38.     //舍去在构造函数中建立起与中介者的联系  
  39. //  public ColleagueB(AbstractMediator mediator) {  
  40. //      super(mediator);  
  41. //  }  
  42.       
  43.     public void self() {  
  44.         System.out.println("同事B --> 做好自己分内的事情 ...");  
  45.     }  
  46.       
  47.     public void out() {  
  48.         System.out.println("同事B --> 请求同事A做好分内工作  ...");  
  49.         super.mediator.execute("ColleagueA""self");  
  50.     }  

 修改后的中介者:

  1. //抽象中介者  
  2. abstract class AbstractMediator {  
  3.       
  4.     //中介者肯定需要保持有若干同事的联系方式  
  5.     protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();  
  6.       
  7.     //中介者可以动态地与某个同事建立联系  
  8.     public void addColleague(String name, AbstractColleague c) {  
  9.           
  10.         // 在中介者这里帮助具体同事建立起于中介者的联系  
  11.         c.setMediator(this); 
  12.         this.colleagues.put(name, c);  
  13.     }     
  14.       
  15.     //中介者也可以动态地撤销与某个同事的联系  
  16.     public void deleteColleague(String name) {  
  17.         this.colleagues.remove(name);  
  18.     }  
  19.       
  20.     //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作  
  21.     public abstract void execute(String name, String method);   
  1. //测试类  
  2. public class Client {  
  3.     public static void main(String[] args) {  
  4.           
  5.         //创建一个中介者  
  6.         AbstractMediator mediator = new Mediator();  
  7.           
  8.         //不用构造函数为具体同事注册中介者来取得联系了  
  9. //      ColleagueA colleagueA = new ColleagueA(mediator);  
  10. //      ColleagueB colleagueB = new ColleagueB(mediator);  
  11.           
  12.         ColleagueA colleagueA = new ColleagueA();  
  13.         ColleagueB colleagueB = new ColleagueB();  
  14.           
  15.         //中介者分别与每个同事建立联系  
  16.         mediator.addColleague("ColleagueA", colleagueA);  
  17.         mediator.addColleague("ColleagueB", colleagueB);  
  18.           
  19.         //同事们开始工作  
  20.         colleagueA.self();  
  21.         colleagueA.out();  
  22.         System.out.println("======================合作愉快,任务完成!\n");  
  23.           
  24.         colleagueB.self();  
  25.         colleagueB.out();  
  26.         System.out.println("======================合作愉快,任务完成!");  
  27.     }  

  测试之后的结果与修改前一样。

本文出自 “蚂蚁” 博客,请务必保留此出处http://haolloyin.blog.51cto.com/1177454/333810

posted on 2012-12-12 13:23 顺其自然EVO 阅读(336) 评论(0)  编辑  收藏 所属分类: 设计模式学习


只有注册用户登录后才能发表评论。


网站导航:
 
<2012年12月>
2526272829301
2345678
9101112131415
16171819202122
23242526272829
303112345

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜