1 定义：
1.1 定义：Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.(用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。)
1.2 通用类图：
Mediator抽象中介者角色
定义统一的接口，用于各同事角色之间的通信。
Concrete Mediator具体中介者角色
协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
Colleague同事角色
每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种方法叫做自发行为（Self-Method），与其他同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。
1.3 通用代码：
public abstract class Mediator {
// 定义同事类
protected ConcreteColleague1 c1;
protected ConcreteColleague2 c2;
// 通过getter/setter方法吧同事类注入进来
public ConcreteColleague1 getC1() {
return c1;
}
public void setC1(ConcreteColleague1 c1) {
this.c1 = c1;
}
public ConcreteColleague2 getC2() {
return c2;
}
public void setC2(ConcreteColleague2 c2) {
this.c2 = c2;
}
// 中介者模式的业务逻辑
public abstract void doSomething1();
public abstract void doSomething2();
}
public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
// 调用同事类的方法，只要是public方法都可以调用
super.c1.selfMethod1();
super.c2.selfMethod2();
}
public void doSomething2() {
super.c1.selfMethod1();
super.c2.selfMethod2();
}
}
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator _mediator) {
this.mediator = _mediator;
}
}
public class ConcreteColleague1 extends Colleague {
// 通过构造函数传递中介者
public ConcreteColleague1(Mediator _mediator) {
super(_mediator);
}
// 自有方法 self-method
public void selfMethod1() {
// 处理自己的业务逻辑
}
// 依赖方法 dep-method
public void depMethod1() {
// 处理自己的业务逻辑
// 自己不能处理的业务逻辑，委托给中介者处理
super.mediator.doSomething1();
}
}
public class ConcreteColleague2 extends Colleague {
// 通过构造函数传递中介者
public ConcreteColleague2(Mediator _mediator) {
super(_mediator);
}
// 自有方法 self-method
public void selfMethod2() {
// 处理自己的业务逻辑
}
// 依赖方法 dep-method
public void depMethod2() {
// 处理自己的业务逻辑
// 自己不能处理的业务逻辑，委托给中介者处理
super.mediator.doSomething2();
}
}注意：
A 在Mediator抽象类中我们只定义了同事类的get/set注入，为什么不使用抽象注入呢？这是因为同事类虽然有抽象，但是没有每个同事类必须要完成的业务方法。当然如果每个同事类都有相同的方法，比如execute 、handler等，那当然注入抽象类，做到依赖倒置。
B 为什么同事类要使用构造函数注入中介者，而中介者注入同事类只使用getter/setter方式呢？因为同事类必须有中介者，而中介者却可以只有部分同事类。
2 优点
减少类间的依赖，把原有的一对多的依赖变成了一对一依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。
3 缺点
中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。
4 应用场景
类之间的联系是必然的，并非有多个依赖时就要使用中介者模式。中介者模式只适用于多个对象间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。
4.1 符合上述紧密耦合标准时使用；
4.2 N个对象之间产生了相互的依赖关系（N>2）；
4.3 多个对象有依赖关系，但是依赖的行为沿不确定或者有发生改变的可能，在这种情况下一般建议采用中介者模式，降低变更引起的风险扩散；
4.4 产品开发。一个明显的例子就是MVC框架，把中介者模式应用到产品中，可以提升产品的性能和扩展性，但是对于项目开发就未必，因为项目是以交付投产为目标，而产品则是以稳定、高效、扩展为宗旨。
生活中的使用情境：
A。机场调度中心；
B。MVC框架；
C。媒体网关；（如MSN通过服务器转发消息，而飞鸽直接使用UDP广播却不是。）
D。各种中介服务；
5 注意事项
5.1 遵循紧密耦合的标准来用中介者模式；
5.2 中介者模式很少用到接口或抽象类，这与依赖倒置原则是冲突的：首先，既然是同事类而不是兄弟类（有相同的血缘），那就说明这些类之间是协作关系，完成不同的任务，处理不同的业务，所以不能在抽象类或接口中严格定义同事类必须具有的方法。因此，如果两个对象不能提炼出共性，就不要刻意去追求两者的抽象，抽象只要定义出模式需要的角色即可。
其次，在一个项目中使用中介者模式可能被多个模块采用，每个中介者所围绕的同事类各不相同，抽象出一个具有共性的中介者也不太可能。
6 扩展
无
7 范例
（进销存案例，这三者间已形成了网状关系）
加入了一个中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就通过中介者进行。每个模块只负责自己的业务逻辑，不属于自己的则丢给中介者来处理，简化了各模块之间的耦合关系，类图如下：
/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
* all.
*/
public abstract class AbstractMediator {
protected Purchase purchase;
protected Sale sale;
protected Stock stock;
// 构造函数
public AbstractMediator() {
purchase = new Purchase(this);
sale = new Sale(this);
stock = new Stock(this);
}
// 中介者最重要的方法，叫做事件方法，处理多个对象之间的关系
public abstract void execute(String str, Object... objects);
}
public class Mediator extends AbstractMediator {
// 中介者最重要的方法
public void execute(String str, Object... objects) {
if (str.equals("purchase.buy")) { // 采购电脑
this.buyComputer((Integer) objects[0]);
} else if (str.equals("sale.sell")) { // 销售电脑
this.sellComputer((Integer) objects[0]);
} else if (str.equals("sale.offsell")) { // 折价销售
this.offSell();
} else if (str.equals("stock.clear")) { // 清仓处理
this.clearStock();
}
}
// 采购电脑
private void buyComputer(int number) {
int saleStatus = super.sale.getSaleStatus();
if (saleStatus > 80) { // 销售情况良好
System.out.println("采购IBM电脑:" + number + "台");
super.stock.increase(number);
} else { // 销售情况不好
int buyNumber = number / 2; // 折半采购
System.out.println("采购IBM电脑：" + buyNumber + "台");
}
}
// 销售电脑
private void sellComputer(int number) {
if (super.stock.getStockNumber() < number) { // 库存数量不够销售
super.purchase.buyIBMcomputer(number);
}
super.stock.decrease(number);
}
// 折价销售电脑
private void offSell() {
System.out.println("折价销售IBM电脑" + stock.getStockNumber() + "台");
}
// 清仓处理
private void clearStock() {
// 要求清仓销售
super.sale.offSale();
// 要求采购人员不要采购
super.purchase.refuseBuyIBM();
}
}中介者Mediator定义了多个private方法，其目的是处理各个对象之间的依赖关系，就是说把原有一个对象要依赖的多个对象的情况移动到中介者的private方法中实现。
但在实际项目中，一般的做法是中介者按照职责进行划分，每个中介者处理一个或多个类似的关联请求。
public abstract class AbstractColleague {
protected AbstractMediator mediator;
public AbstractColleague(AbstractMediator _mediator) {
this.mediator = _mediator;
}
}
public class Purchase extends AbstractColleague {
public Purchase(AbstractMediator _mediator) {
super(_mediator);
}
// 采购IBM型号的电脑
public void buyIBMcomputer(int number) {
super.mediator.execute("purchase.buy", number);
}
// 不在采购IBM电脑
public void refuseBuyIBM() {
System.out.println("不再采购IBM电脑");
}
}
public class Stock extends AbstractColleague {
public Stock(AbstractMediator _mediator) {
super(_mediator);
}
// 刚开始有100台电脑
private static int COMPUTER_NUMBER = 100;
// 库存增加
public void increase(int number) {
COMPUTER_NUMBER = COMPUTER_NUMBER + number;
System.out.println("库存数量为：" + COMPUTER_NUMBER);
}
// 库存降低
public void decrease(int number) {
COMPUTER_NUMBER = COMPUTER_NUMBER - number;
System.out.println("库存数量为：" + COMPUTER_NUMBER);
}
// 获得库存数量
public int getStockNumber() {
return COMPUTER_NUMBER;
}
// 存货压力大了，就要通知采购人员不要采购，销售人员要尽快销售
public void clearStock() {
System.out.println("清理存货数量为：" + COMPUTER_NUMBER);
super.mediator.execute("stock.clear");
}
}
public class Sale extends AbstractColleague {
public Sale(AbstractMediator _mediator) {
super(_mediator);
}
// 销售IBM型号的电脑
public void sellIBMComputer(int number) {
super.mediator.execute("sale.sell", number);
System.out.println("销售IBM电脑" + number + "台");
}
// 反馈销售情况,0——100之间变化，0代表根本就没人卖，100代表非常畅销，出1一个卖一个
public int getSaleStatus() {
Random rand = new Random(System.currentTimeMillis());
int saleStatus = rand.nextInt(100);
System.out.println("IBM电脑的销售情况为：" + saleStatus);
return saleStatus;
}
// 折价处理
public void offSale() {
super.mediator.execute("sale.offsell");
}
}
public class Client {
public static void main(String[] args) {
AbstractMediator mediator = new Mediator();
// 采购人员采购电脑
System.out.println("------采购人员采购电脑--------");
Purchase purchase = new Purchase(mediator);
purchase.buyIBMcomputer(100);
// 销售人员销售电脑
System.out.println("\n------销售人员销售电脑--------");
Sale sale = new Sale(mediator);
sale.sellIBMComputer(1);
// 库房管理人员管理库存
System.out.println("\n------库房管理人员清库处理--------");
Stock stock = new Stock(mediator);
stock.clearStock();
}
}
在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动（行为），与自己无关的活动就丢给中介者处理。
转自：http://blog.csdn.net/yuanlong_zheng/article/details/7574441
扫一扫
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
