介绍
中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。
类图说明
这里我们列举一个购买以及出售二手车的例子，刚开始购买二手车，增加库存，而后开始销售二手车。不难看出，购买、销售以及库存之间的关系是两两相关的，这样子的关系图是比较复杂，也不符合迪米特法则，所以加入了中介者。在类图中我们定义一个抽象中介对象，该对象定义了一个excute方法，而真正逻辑的实现是在Mediator对象里实现，然后分别定义Purchase,Sale,Stock对象，分别实现AbstractColleague对象，该对象依赖中介者对象实例化。
代码示例
文件结构如下：
示例代码如下：
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);
}
public void buyCar(int num){
super.mediator.execute("buyCar",num);
}
public void stopBuyCar(){
System.out.println("已停止购买车辆");
}
}
public class Sale extends AbstractColleague{
private int sellNum = 0;
public Sale(AbstractMediator mediator) {
super(mediator);
}
public void sellCar(int num){
sellNum = sellNum + num;
this.mediator.execute("sellCar",num);
}
public int getSellNum(){
return this.sellNum;
}
}
public class Stock extends AbstractColleague{
public int getTotalNum() {
return totalNum;
}
private int totalNum = 0;
public Stock(AbstractMediator mediator) {
super(mediator);
}
public void increase(int num){
totalNum = totalNum + num;
System.out.println("已购买:"+num+"，当前库存为："+totalNum);
}
public void decrease(int num){
totalNum = totalNum - num;
System.out.println("已销售:"+num+"，当前库存为："+totalNum);
}
public void clearStock(){
this.mediator.execute("clearStock");
}
}
public abstract class AbstractMediator {
protected Purchase purchase;
protected Sale sale;
protected Stock stock;
public AbstractMediator(){
this.purchase = new Purchase(this);
this.sale = new Sale(this);
this.stock = new Stock(this
);
}
public abstract void execute(String str,Object ... objects);
}
public class Mediator extends AbstractMediator {
@Override
public void execute(String str, Object... objects) {
switch (str){
case "buyCar":
buyCar((int)objects[0]);
break;
case "sellCar":
sellCar((int)objects[0]);
break;
case "clearStock":
clearStock();
break;
}
}
private void sellCar(int num) {
if(this.stock.getTotalNum() < num){
System.out.println("库存数量不够,无法出售,通知采购中");
this.purchase.buyCar(this.stock.getTotalNum() - num);
}
this.stock.decrease(num);
}
private void clearStock() {
this.purchase.stopBuyCar();
System.out.println("开始销售剩下的所有库存："+this.stock.getTotalNum());
this.sale.sellCar(this.stock.getTotalNum());
}
private void buyCar(int num) {
// 判断售卖车小于10，则购买车的数量需要减半
if(this.sale.getSellNum() < 10 && this.stock.getTotalNum() != 0){
System.out.println("售卖车小于10，则购买车的数量需要减半");
num = num/2;
}
// 入库存
this.stock.increase(num);
}
}
public class MediatorPattern {
public static void main(String[] args) {
AbstractMediator mediator = new Mediator();
Purchase purchase = new Purchase(mediator);
purchase.buyCar(20);
Sale sale = new Sale(mediator);
sale.sellCar(10);
Stock stock = new Stock(mediator);
stock.clearStock();
}
}
运行结果如下：
应用场景
- 系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象
- 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类
实际应用有MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者
优缺点
优点
- 降低了类的复杂度，将一对多转化成了一对一
- 各个类之间的解耦
- 符合迪米特原则
缺点
- 中介者会庞大，变得复杂难以维护