设计模式--中介者模式Mediator（行为型）

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();
}
}

在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动（行为），与自己无关的活动就丢给中介者处理。

转自：/article/2369009.html