Java设计模式--中介者模式【Mediator Pattern】

        前两天，班长在微信群里通知，马上就是毕业十周年了，准备组织一个母校的十周年同学聚会。届时，许多多年不联系的同学都在群里活跃了起来，大家纷纷回想大学的美好时光，历历在目，仿若昨天。想起初中时，没有微信，没有QQ，暑假期间老师给大家布置任务，只能让某个同学一对一地通知，然后一对一地回复。大概情景是这样的：

         一个班级有50多个同学，如果把这个50多个同学都放到这个通信网状结构上，那就是真真的“蜘蛛网”了，一个消息反复通知不说。原本把一个系统分割成一些对象是可以增强复用性的，但是现在的情况是，这些兑现之间存在着大量的联系，耦合性极高。这是很不利于复用的，同时这种情况使得系统的灵活性大大的降低，使得对系统的扩展很难，要是新转来一个学生的话，要改动的地方就多了去了。代码如下：  

package com.pattern.mediator.v1;public abstract class AbstractClassmate {protected String name;    protected String message;        public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public AbstractClassmate(String name) {this.name = name;}public String getName() {return name;}public abstract void sendMessage(String message,AbstractClassmate mate);}

package com.pattern.mediator.v1;public class ClassmateA extends AbstractClassmate {public ClassmateA(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractClassmate mate) {          this.message=message;          mate.setMessage(message);          System.out.println(this.getName()+"通知"+mate.getName()+":"+message);}}

package com.pattern.mediator.v1;public class ClassmateB extends AbstractClassmate {public ClassmateB(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractClassmate mate) {this.message=message;mate.setMessage(message);System.out.println(this.getName()+"通知"+mate.getName()+":"+message);}}

package com.pattern.mediator.v1;public class ClassmateC extends AbstractClassmate {public ClassmateC(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractClassmate mate) {this.message=message;mate.setMessage(message);System.out.println(this.getName()+"通知"+mate.getName()+":"+message);}}

package com.pattern.mediator.v1;public class Client {    public static void main(String[] args){    AbstractClassmate mateA=new ClassmateA("小军");    AbstractClassmate mateB=new ClassmateB("小红");    AbstractClassmate mateC=new ClassmateC("小新");    mateA.sendMessage("10月8号到母校参加同学10周年聚会呀！", mateB);    mateB.sendMessage("好的，收到！", mateA);    mateA.sendMessage("10月8号到母校参加同学10周年聚会呀！", mateC);    mateC.sendMessage("不好意思，我有事去不了！", mateB);    }}

     测试结果：

    

  如果引入中介者模式，那么同学类之间的通信关系将变为星型结构，从图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会把所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

     

      那么，什么是中介者模式呢？

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

中介者模式又称为调停者模式，共分为3部分：

  抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。

  中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类

  同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

  再说说同学聚会的事儿，现在班长借助“微信”这个中介者，只需要在群里发出消息，大家就能收到消息。再各自发出自己的回复，班长和其他同学都能收到回复。代码如下：

package com.pattern.mediator.v2;/** * 中介者抽象类  * @author Jerify * */public abstract class AbstractMediator {  public abstract void sendMessage(String message,AbstractClassmate mate);//给同学发送消息}

package com.pattern.mediator.v2;import java.util.ArrayList;import java.util.List;public class Mediator extends AbstractMediator {protected List<AbstractClassmate> matelist=new ArrayList<AbstractClassmate>();public void addClassmate(AbstractClassmate mateA){matelist.add(mateA);}@Overridepublic void sendMessage(String message, AbstractClassmate mate) {System.out.println("同学"+mate.getName()+"说："+message);for(AbstractClassmate mateX:matelist){//中介将消息广播给其他同学，在此模拟通知 if(!mate.getName().equals(mateX.getName())){System.out.println("----------中介者通知"+mateX.getName()+"-------"+mate.getName()+"说："+message);}}}}

package com.pattern.mediator.v2;/** * 同学抽象类 * @author Jerify * */public abstract class AbstractClassmate {protected String name;    protected String message;    protected AbstractMediator mediator;      public AbstractClassmate(String name) {super();this.name = name;}public String getName() {return name;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public AbstractMediator getMediator() {return mediator;}public void setMediator(AbstractMediator mediator) {this.mediator = mediator;}public abstract void sendMessage(String message,AbstractMediator mediator);//发送消息}

package com.pattern.mediator.v2;public class ClassmateA extends AbstractClassmate{public ClassmateA(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者，中介者再将消息广播给其他同学 this.message=message;this.mediator=mediator;this.mediator.sendMessage(message, this);}}

package com.pattern.mediator.v2;public class ClassmateB extends AbstractClassmate{public ClassmateB(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者，中介者再将消息广播给其他同学this.message=message;this.mediator=mediator;this.mediator.sendMessage(message, this);}}

package com.pattern.mediator.v2;public class ClassmateC extends AbstractClassmate{public ClassmateC(String name) {super(name);}@Overridepublic void sendMessage(String message, AbstractMediator mediator) {//同学发送消息给中介者，中介者再将消息广播给其他同学this.message=message;this.mediator=mediator;this.mediator.sendMessage(message, this);}}

客户端测试：

package com.pattern.mediator.v2;/** * 客户端测试类  * @author Jerify * */public class Client {public static void main(String[] args) {Mediator mediator=new Mediator();//中介者    AbstractClassmate mateA=new ClassmateA("小军");AbstractClassmate mateB=new ClassmateB("小红");AbstractClassmate mateC=new ClassmateC("小新");mediator.addClassmate(mateA);mediator.addClassmate(mateB);mediator.addClassmate(mateC);mateA.sendMessage("10月8号到母校参加同学10周年聚会呀！收到请回复。", mediator);//同学A跟中介说者mateB.sendMessage("好的，收到！", mediator);//同学B告诉中介者mateC.sendMessage("不好意思，我有事去不了！", mediator);//同学C告诉中介者}}

测试结果：

使用中介者模式的优点：

1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。

2.提高系统的灵活性，使得系统易于扩展和维护。

使用中介者模式的缺点：

   中介者模式的缺点是显而易见的，因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。

源码下载：http://download.csdn.net/download/pelifymeng2/9994744