调停者模式(Mediator)

调停者模式(Mediator) 属于对象的行为模式

 

1.1.1       定义

 

调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显作用。从而使他们可以松散偶合。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化,把对象在小尺度的行为上与其他对象的相互作用分开处理。

 

1.1.2       结构

 

                       

 

  • Mediator:抽象调停者角色,它定义出同事对象到调停者对象得接口,这个角色一般由Java抽象类实现.
  • ConcreteMediator:具体调停者模式,从抽象调停者继承,实现了超类所声明的事件方法,它从具体同事对象接收消息,向具体同事对象发出命令.
  • Colleague:抽象同事类角色,它定义了调停者同事对象的接口,它只知道调停者而不知道其余同事对象.
  • colleague1、colleague2:具体同事类角色,从抽象同事类继承而来,每个具体同事类都知道本身在小范围内的行为,而不知道它在大范围内的目的.

 

 

 

 

 

1.1.3       适应性

 

当对象之间的交互操作很多,且每个对象的行为操作都依赖彼此时,为防止在修改一个对象的行为时,同时涉及到修改很多其他对象的行为,可采用调停者模式,来解决紧耦合问题.
该模式将对象之间的多对多关系变成一对多关系,调停者对象将系统从网状结构变成以调停者为中心的星形结构,达到降低系统的复杂性,提高可扩展性的作用.

 

1.1.4       优缺点

 

  1. 减少了子类生成Mediator将原本分布于多个对象间的行为集中在一起,改变这些行为只需生成Mediator的子类即可,这样各个Colleague类可被重用。
  2. 它将各Colleague解耦。Mediator有利于各Colleague间的松耦合,你可以独立的改变和复用各Colleague类和Mediator类。
  3. 它简化了对象协议用Mediator和各Colleague间的一对多的交互来代替多对多的交互。一对多的关系更易于理解、维护和扩展。
  4. 它对对象如何协作进行了抽象将中介作为一个独立的概念并将其封装在一个对象中,使你将注意力从对象各自本身的行为转移到它们之间的交互上来。这有助于弄清楚一个系统中的对象是如何交互的。
  5. 它使控制集中化,中介者模式将交互的复杂性变为中介者的复杂性。因为中介者封装了协议,它可能变得比任一个Colleague都复杂。这可能使得中介者自身成为一个难于维护的庞然大物。

 

相关模式

  • Facade 模式与 Mediator 模式的不同之处在于它是对一个对象子系统进行抽象,从而提供了一个更为方便的接口。它的协议是单向的,即 Facade 对象对这个子系统类提出要求,但反之则不行。Mediator 提供了各 Colleague 对象不支持或不能支持的协作行为,而协议是多向的。
  • Colleague 可以使用 Observer 模式与 Mediator 通信。

1.1.5       适用的情况举例

 

  • WTO组织:它是一个协调组织,它将各贸易区自行进行的相互协调的强耦合变成了松散合;
  •  4个MM打麻将,相互之间谁应该给谁多少钱算不清楚了,某人担任调停者,各MM按照各自的筹码数算钱,赚了钱的从调停者这里拿,赔了钱的也付给调停者;
  •  租赁中介:很多人有出租房子的需求,也有不少人需要租房,租赁中介在其中担任了调停者的角色, 疏通了两者之间的复杂关系,也方便了两者。

 

1.1.6       示例

 

//抽象同事类  

abstract class AbstractColleague {  

    protected AbstractMediator mediator;  

      

    /**既然有中介者,那么每个具体同事必然要与中介者有联系,  

     * 否则就没必要存在于 这个系统当中,这里的构造函数相当  

     * 于向该系统中注册一个中介者,以取得联系  

     */ 

    public AbstractColleague(AbstractMediator mediator) {  

        this.mediator = mediator;  

    }  

      

    // 在抽象同事类中添加用于与中介者取得联系(即注册)的方法  

    public void setMediator(AbstractMediator mediator) {  

        this.mediator = mediator;  

    }  

}  

 

//具体同事A  

class ColleagueA extends AbstractColleague {  

      

    //每个具体同事都通过父类构造函数与中介者取得联系  

    public ColleagueA(AbstractMediator mediator) {  

        super(mediator);  

    }  

      

    //每个具体同事必然有自己分内的事,没必要与外界相关联  

    public void self() {  

        System.out.println("同事A --> 做好自己分内的事情 ...");  

    }  

      

    //每个具体同事总有需要与外界交互的操作,通过中介者来处理这些逻辑并安排工作  

    public void out() {  

        System.out.println("同事A --> 请求同事B做好分内工作 ...");  

        super.mediator.execute("ColleagueB", "self");  

    }  

}  

 

//具体同事B  

class ColleagueB extends AbstractColleague {  

      

    public ColleagueB(AbstractMediator mediator) {  

        super(mediator);  

    }  

      

    public void self() {  

        System.out.println("同事B --> 做好自己分内的事情 ...");  

    }  

      

    public void out() {  

        System.out.println("同事B --> 请求同事A做好分内工作  ...");  

        super.mediator.execute("ColleagueA", "self");  

    }  

中介者类族:

//抽象中介者  

abstract class AbstractMediator {  

      

    //中介者肯定需要保持有若干同事的联系方式  

    protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();  

      

    //中介者可以动态地与某个同事建立联系  

    public void addColleague(String name, AbstractColleague c) {  

        this.colleagues.put(name, c);  

    }      

      

    //中介者也可以动态地撤销与某个同事的联系  

    public void deleteColleague(String name) {  

        this.colleagues.remove(name);  

    }  

      

    //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作  

    public abstract void execute(String name, String method);   

}  

 

//具体中介者  

class Mediator extends AbstractMediator{  

      

    //中介者最重要的功能,来回奔波与各个同事之间  

    public void execute(String name, String method) {  

          

        if("self".equals(method)){  //各自做好分内事  

            if("ColleagueA".equals(name)) {  

                ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  

                colleague.self();  

            }else {  

                ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  

                colleague.self();  

            }  

        }else { //与其他同事合作  

            if("ColleagueA".equals(name)) {  

                ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  

                colleague.out();  

            }else {  

                ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  

                colleague.out();  

            }  

        }  

    }  

测试类:

//测试类  

public class Client {  

    public static void main(String[] args) {  

          

        //创建一个中介者  

        AbstractMediator mediator = new Mediator();  

          

        //创建两个同事  

        ColleagueA colleagueA = new ColleagueA(mediator);  

        ColleagueB colleagueB = new ColleagueB(mediator);  

          

        //中介者分别与每个同事建立联系  

        mediator.addColleague("ColleagueA", colleagueA);  

        mediator.addColleague("ColleagueB", colleagueB);  

          

        //同事们开始工作  

        colleagueA.self();  

        colleagueA.out();  

        System.out.println("======================合作愉快,任务完成!\n");  

          

        colleagueB.self();  

        colleagueB.out();  

        System.out.println("======================合作愉快,任务完成!");  

    }  

}

posted on 2012-06-12 13:24  duanxz  阅读(865)  评论(0编辑  收藏  举报