设计模式——中介者模式（调停者模式）

中介者模式

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

组成部分：

• Mediator抽象中介者：定义统一的接口，用于各同事角色之间的通信。
• Concrete Mediator具体中介者：通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
• Colleague同事：每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。

每个同事类的行为分为两种：

• 一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为（Self-Method），与其他的同事类或中介者没有任何的依赖；
• 第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

通用抽象中介者Mediator：

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

通用中介者ConcreteMediator：

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

抽象同事类Colleague：

public abstract class Colleague { 
    protected Mediator mediator; 
    public Colleague(Mediator _mediator){ 
        this.mediator = _mediator; 
    } 
}

具体同事类ConcreteColleague1和ConcreteColleague2：

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

为什么同事类要使用构造函数注入中介者，而中介者使用getter/setter方式注入同事类呢？这是因为同事类必须有中介者，而中介者却可以只有部分同事类。

---

中介者模式的优点

减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖， 同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。

中介者模式的缺点

中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

中介者模式的使用场景

中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。

可以在如下的情况下尝试使用中介者模式：

• N个对象之间产生了相互的依赖关系（N＞2）。
• 多个对象有依赖关系，但是依赖的行为尚不确定或者有发生改变的可能，在这种情况下一般建议采用中介者模式，降低变更引起的风险扩散。
• 产品开发。一个明显的例子就是MVC框架，把中介者模式应用到产品中，可以提升产品的性能和扩展性，但是对于项目开发就未必，因为项目是以交付投产为目标，而产品则是以稳定、高效、扩展为宗旨。

---

中介者模式的实际应用

• 机场调度中心。
• MVC框架（Model-View-Controller）：其中Controller就是中介者，把Model和View隔离开。
• 媒体网关：MSN（张三）-MSN服务器-MSN（李四）。
• 中介服务。

---

中介者模式实例

这里我们采用一个店家对货物的采购、销售、存储作为实例，来对中介者模式进行简单实现。

从下面的模块关系图中可以看出，在没有中介者之前，三个模块之间是紧耦合的状态，每个模块都需要依赖其余的两个模块，其间的操作非常的繁琐，是多对多的关系。

而中介者的引入就像多台计算机通过交换机交换数据一样：

三个模块也都像这种星型模式一样，通过中介者进行对话，将多对多的关系变成一对多的关系：

通过分析我们可以产生以下类图：

类图中有两个抽象类AbstractMediator（抽象中介者）和AbstractColeague（抽象同事），AbstractColeague类产生的每个同事对象只是与中介者Mediator之间产生依赖，与其他对象之间没有直接关系，AbstractMediator的作用是实现中介者的抽象定义，定义了一个抽象方法execute。execute是AbstractMediator中最重要的方法。

（1）AbstractMediator（抽象中介者类）

import com.sfq.action.Purchase;
import com.sfq.action.Sale;
import com.sfq.action.Stock;
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);
}

（2）Mediator（中介者类）

import com.sfq.impl.AbstractMediator;
public class Mediator extends AbstractMediator {
	//中介者最重要的方法
	@Override
	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 + "台");
			super.stock.increase(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();
	}
}

（3）AbstractColeague（抽象同事类）

public abstract class AbstractColleague {
	protected AbstractMediator mediator;
	public AbstractColleague(AbstractMediator mediator) {
		this.mediator = mediator;
	}	
}

（4）三个同事类

import com.sfq.impl.AbstractColleague;
import com.sfq.impl.AbstractMediator;
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电脑");
	}
}

import com.sfq.impl.AbstractColleague;
import com.sfq.impl.AbstractMediator;
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 static int getStockNumber() {
		return COMPUTER_NUMBER;
	}	
	//存货压力大，通知采购人员不采购，售货人员尽快销售
	public void clearStock() {
		System.out.println("清理存货数量为：" + COMPUTER_NUMBER);
		super.mediator.execute("stock.clear");
	}
}

import java.util.Random;
import com.sfq.impl.AbstractColleague;
import com.sfq.impl.AbstractMediator;
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表示非常畅销，出一个卖一个
	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");
	}
}

（5）场景类Client

import com.sfq.action.Mediator;
import com.sfq.action.Purchase;
import com.sfq.action.Sale;
import com.sfq.action.Stock;
import com.sfq.impl.AbstractMediator;
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("------销售人员销售电脑------");
		Sale sale = new Sale(mediator);
		sale.sellIBMComputer(1);
		System.out.println("------库房管理人员清库处理------");
		Stock stock = new Stock(mediator);
		stock.clearStock();
	}
}

结果
------采购人员采购电脑------
IBM电脑的销售情况为：5
采购IBM电脑：50台
库存数量为：150
------销售人员销售电脑------
库存数量为：149
销售IBM电脑1台
------库房管理人员清库处理------
清理存货数量为：149
折价销售IBM电脑149台
不再采购IBM电脑