您的位置：首页 > 编程语言 > Java开发

java设计模式---调停者模式

2013-07-19 10:32 369 查看

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

举例：在一个公司里面，有很多部门、员工（我们统称他们互相为Colleague“同事”），为了完成一定的任务，“同事”之间肯定有许多需要互相配合、交流的过程。如果由各个“同事”频繁地到处去与自己有关的“同事”沟通，这样肯定会形成一个多对多的杂乱的联系网络而造成工作效率低下。此时就需要一位专门的“中介者”给各个“同事”分配任务，以及统一跟进大家的进度并在“同事”之间实时地进行交互，保证“同事”之间必须的沟通交流。很明显我们知道此时的“中介者”担任了沟通“同事”彼此之间的重要角色了，“中介者”使得每个“同事”都变成一对一的联系方式，减轻了每个“同事”的负担，增强工作效率。大概理清上面简单例子中的意图之后，给出中介者模式适用场景：1、一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。2、一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。3、想定制一个分布在多个类中的行为，而又不想生成太多的子类。其实，中介者模式又被称为“调停者”模式，我们可以理解为一群小孩子（同事）吵架了，这时就很需要一位大人（调停者）过来处理好小孩子们的关系，以免发生不必要的冲突。“中介者”和“调停者”只不过是同一个英语单词“Mediator”的不同翻译罢了。反正最最重要的是：中介者就是一个处于众多对象，并恰当地处理众多对象之间相互之间的联系的角色。下面给出具体的代码例子，对比通用类图增加了AbstractColleague抽象同事类和AbstractMediator抽象中介者，另外就是两个具体同事类和一个具体中介者，代码中有较多注释，相应类图也不给出了，应该不难理解的：同事类族：

//抽象同事类
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("======================合作愉快，任务完成！");
}
}

测试结果：

同事A --> 做好自己分内的事情 ...
同事A --> 请求同事B做好分内工作 ...
同事B --> 做好自己分内的事情 ...
======================合作愉快，任务完成！

同事B --> 做好自己分内的事情 ...
同事B --> 请求同事A做好分内工作  ...
同事A --> 做好自己分内的事情 ...
======================合作愉快，任务完成！

虽然以上代码中只有两个具体同事类，并且测试类中也只是创建了两个同事，但是这些我们都可以根据中介者模式的宗旨进行适当地扩展，即增加具体同事类，然后中介者就得担负更加重的任务了。为啥？我们看到上面具体中介者类Mediator中的execute()方法中现在就有一堆冗长的判断代码了。虽然可以把它分解并增加到Mediator类中的其它private方法中，但是具体的业务逻辑是少不了的。所以，在解耦同事类之间的联系的同时，中介者自身也不免任务过重，因为几乎所有的业务逻辑都交代到中介者身上了，可谓是“万众期待”的一个角色了。这就是中介者模式的不足之处了。此外，上面这个代码例子是相当理想的了，有时候我们根本抽取不了“同事”之间的共性来形成一个AbstractColleague抽象同事类，这也大大增加了中介者模式的使用难度。

修改：

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

修改后的同事类族：

//抽象同事类
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) {

// 在中介者这里帮助具体同事建立起于中介者的联系
c.setMediator(this);
this.colleagues.put(name, c);
}

//中介者也可以动态地撤销与某个同事的联系
public void deleteColleague(String name) {
this.colleagues.remove(name);
}

//中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作
public abstract void execute(String name, String method);
}

//测试类
public class Client {
public static void main(String[] args) {

//创建一个中介者
AbstractMediator mediator = new Mediator();

//不用构造函数为具体同事注册中介者来取得联系了
//      ColleagueA colleagueA = new ColleagueA(mediator);
//      ColleagueB colleagueB = new ColleagueB(mediator);

ColleagueA colleagueA = new ColleagueA();
ColleagueB colleagueB = new ColleagueB();

//中介者分别与每个同事建立联系
mediator.addColleague("ColleagueA", colleagueA);
mediator.addColleague("ColleagueB", colleagueB);

//同事们开始工作
colleagueA.self();
colleagueA.out();
System.out.println("======================合作愉快，任务完成！\n");

colleagueB.self();
colleagueB.out();
System.out.println("======================合作愉快，任务完成！");
}
}

本文来自：http://haolloyin.blog.51cto.com/1177454/333810/

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航