中介者模式又叫调停模式，定义如下：用一个中介者对象封装一系列的对象的交互，中介者使各个对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。
通用类图如下：
从图中可以看到，中介者模式由一下几部分组成:
1.抽象中介者模式Mediator
抽象中介模式定义统一的接口，用于各同事角色之间的通信
2.具体中介者模式ConcreteMediator
具体中介者角色通过协调各个同事角色实现协作行为，因此它必须依赖于各个同事角色
3.同事角色Colleague
每一个同事角色都知道中介者角色，而且其他的同事角色通信的时候，一定要通过中介角色的协作
说完中介者的通用类图，下面看看如何应用以及应用中介者模式有哪些好处
现实生活中存在很多的中介者模式，比如和我们自身相关的那就是租房，大家从学校毕业来到社会上工作的第一件事可能就是租房（有房的除外），然后才是找工作，还有就是机场的调度中心其实也是一个中介者模式的体现，还有我们做开发现在用的最多一种结构MVC也是中介模式的体现，其中C叫做控制器，V--视图，M--业务逻辑，前端想要显示什么数据首先会询问C然后又C去询问M而不是通过V直接询问M，这样的设计就是为了松耦合，这也是中介者模式的优点，下面我们以一个实际应用来说明：
一家奔驰的4S店主要设计到的角色有：销售部门、采购部门、库存部门
销售部门:
销售部门要反馈销售情况，畅销就多采购，不畅销就少采购，同事卖出后要通知库存部门
库存部门：
即使是畅销情况，如果库存已经超过某个上限也就不需要在采购了
下面是没有使用中介者模式的类图
/**
* 销售部门
*
*/
public class Sale {
// 销售奔驰汽车
public void sellBenz(int carNum) {
// 访问库存
Stock stock = new Stock();
// 判断购买量和库存量
if (stock.getStockNum() < carNum) {
// 库存不够，通知采购部门进行采购
Purchase purchase = new Purchase();
purchase.buyBenz(carNum);
}
System.out.println("销售汽车：" + carNum + "辆");
// 更新库存
stock.decrease(carNum);
}
// 打折销售
public void offSale() {
// 访问库存
Stock stock = new Stock();
System.out.println("打折处理汽车数量:" + stock.getStockNum());
}
// 获取销售状态，用数字0-10来表示，0没有销售，10代表非常畅销
public int getSaleStatus() {
Random random = new Random(System.currentTimeMillis());
int saleStatus = random.nextInt(10);
System.out.println("汽车的销售情况：" + saleStatus);
return saleStatus;
}
}
/**
* 采购部门
*
*/
public class Purchase {
// 采购奔驰汽车
public void buyBenz(int carNum) {
// 询问销售部门汽车的销售情况，如果销售状态>8则进行采购，如果是0就暂时不采购，如果处于0--8之间则进行折半采购
Sale sale = new Sale();
if (sale.getSaleStatus() == 0) {
System.out.println("销售情况不好,暂时不采购");
} else if (sale.getSaleStatus() < 8) {
int halfNum = carNum / 2;
System.out.println("销售情况不算理想，进行折半采购，采购汽车数量:" + halfNum);
// 更新库存
Stock stock = new Stock();
stock.increase(halfNum);
} else {
System.out.println("采购汽车:" + carNum + "量");
// 更新库存
Stock stock = new Stock();
stock.increase(carNum);
}
}
// 不在采购
public void refuseBuyBenz() {
System.out.println("不在采购汽车");
}
}
/**
* 库存部门
*
*/
public class Stock {
// 库存中默认100辆奔驰
public static int DEFAULT_NUM = 100;
// 库存汽车容量的上限
public static final int MAX_NUM = 200;
// 增加库存
public void increase(int carNum) {
DEFAULT_NUM += carNum;
System.out.println("现在库存量：" + DEFAULT_NUM);
}
// 减少库存
public void decrease(int catNum) {
DEFAULT_NUM -= catNum;
System.out.println("现在库存剩余量:" + DEFAULT_NUM);
}
// 获取库存量
public int getStockNum() {
return DEFAULT_NUM;
}
// 清理库存
public void clearStock() {
// 通知销售
Sale sale = new Sale();
sale.offSale();
// 通知采购
Purchase purchase = new Purchase();
purchase.refuseBuyBenz();
}
}
public class Client {
public static void main(String[] args) {
// 采购人员采购汽车
System.out.println("-----采购汽车------");
Purchase purchase = new Purchase();
purchase.buyBenz(20);
// 销售人员销售汽车
System.out.println("-----销售汽车------");
Sale sale = new Sale();
sale.sellBenz(50);
// 清理库存
System.out.println("-----清理库存-------");
Stock stock = new Stock();
stock.clearStock();
}
}
相信大家已经看出这段程序的问题，那就是销售、采购、库存之间耦合太紧了，稍微有一个程序需要修改，那么可能就会导致一片程序的修改，下面看看引入中介者模式之后的效果：
/**
* 抽象中介者
*
*/
public abstract class AbstractMediator {
protected Sale sale;
protected Purchase purchase;
protected Stock stock;
public AbstractMediator() {
sale = new Sale(this);
purchase = new Purchase(this);
stock = new Stock(this);
}
protected abstract void exec(String str, Integer... num);
}
/**
*
* 具体中介者
*/
public class Mediator extends AbstractMediator {
/**
* @param str
* @param num
*/
@Override
protected void exec(String str, Integer... num) {
if ("buy".equals(str)) {
this.buyBenz(num[0]);
}
if ("sell".equals(str)) {
this.sellBenz(num[0]);
}
if ("offSale".equals(str)) {
this.offSale();
}
if ("clear".equals(str)) {
this.clearStock();
}
}
// 清理库存
public void clearStock() {
// 通知销售
super.sale.offSale();
// 通知采购
super.purchase.refuseBuyBenz();
}
// 打折销售
private void offSale() {
// 访问库存
System.out.println("打折处理汽车数量:" + super.stock.getStockNum());
}
// 采购奔驰汽车
private void buyBenz(int carNum) {
// 询问销售部门汽车的销售情况，如果销售状态>8则进行采购，如果是0就暂时不采购，如果处于0--8之间则进行折半采购
if (super.sale.getSaleStatus() == 0) {
System.out.println("销售情况不好,暂时不采购");
} else if (super.sale.getSaleStatus() < 8) {
int halfNum = carNum / 2;
System.out.println("销售情况不算理想，进行折半采购，采购汽车数量:" + halfNum);
// 更新库存
super.stock.increase(halfNum);
} else {
System.out.println("采购汽车:" + carNum + "量");
// 更新库存
super.stock.increase(carNum);
}
}
// 销售奔驰汽车
private void sellBenz(int carNum) {
// 访问库存
// 判断购买量和库存量
if (super.stock.getStockNum() < carNum) {
// 库存不够，通知采购部门进行采购
super.purchase.buyBenz(carNum);
}
System.out.println("销售汽车：" + carNum + "辆");
// 更新库存
super.stock.decrease(carNum);
}
}
/**
* 抽象同事类
*
*/
public abstract class AbstractColleague {
protected AbstractMediator mediator;
public AbstractColleague(AbstractMediator mediator) {
this.mediator = mediator;
}
}
/**
* 销售部门
*
*/
public class Sale extends AbstractColleague {
/**
* @param mediator
*/
public Sale(AbstractMediator mediator) {
super(mediator);
}
// 销售奔驰汽车
public void sellBenz(int carNum) {
super.mediator.exec("sell", 50);
}
// 打折销售
public void offSale() {
super.mediator.exec("offSale");
}
// 获取销售状态，用数字0-10来表示，0没有销售，10代表非常畅销
public int getSaleStatus() {
Random random = new Random(System.currentTimeMillis());
int saleStatus = random.nextInt(10);
System.out.println("汽车的销售情况：" + saleStatus);
return saleStatus;
}
}
/**
* 库存部门
*
*/
public class Stock extends AbstractColleague {
/**
* @param mediator
*/
public Stock(AbstractMediator mediator) {
super(mediator);
// TODO Auto-generated constructor stub
}
// 库存中默认100辆奔驰
public static int DEFAULT_NUM = 100;
// 库存汽车容量的上限
public static final int MAX_NUM = 200;
// 增加库存
public void increase(int carNum) {
DEFAULT_NUM += carNum;
System.out.println("现在库存量：" + DEFAULT_NUM);
}
// 减少库存
public void decrease(int catNum) {
DEFAULT_NUM -= catNum;
System.out.println("现在库存剩余量:" + DEFAULT_NUM);
}
// 获取库存量
public int getStockNum() {
return DEFAULT_NUM;
}
// 清理库存
public void clearStock() {
super.mediator.exec("clear", DEFAULT_NUM);
}
}
/**
* 采购部门
*
*/
public class Purchase extends AbstractColleague {
/**
* @param mediator
*/
public Purchase(AbstractMediator mediator) {
super(mediator);
}
// 采购奔驰汽车
public void buyBenz(int carNum) {
super.mediator.exec("buy", 20);
}
// 不在采购
public void refuseBuyBenz() {
System.out.println("不在采购汽车");
}
}
public class Client {
public static void main(String[] args) {
// 创建一个中介者
AbstractMediator mediator = new Mediator();
// 采购人员采购汽车
System.out.println("-----采购汽车------");
Purchase purchase = new Purchase(mediator);
purchase.buyBenz(20);
// 销售人员销售汽车
System.out.println("-----销售汽车------");
Sale sale = new Sale(mediator);
sale.sellBenz(50);
// 清理库存
System.out.println("-----清理库存-------");
Stock stock = new Stock(mediator);
stock.clearStock();
}
}
中介者模式简单，但是简单并不代表容易使用，而且有时候很容易被误用，大家可以尝试在如下情况使用中介者模式：
1.多个对象之间产生了相互依赖的关系
2.多个对象之间有依赖关系，但是依赖行为尚不确定或者有发生改变的可能
相关推荐
C#设计模式之中介者模式小例子
23种设计模式之中介者模式对中介者模式进行了简单的介绍，并附带了例子程序，和大家分享
Java设计模式之中介者模式__动力节点共6页.pdf.zip
从实际例子说明中介者模式，进而引出中介者模式的原理，使用情况和特点等
中介者模式（Mediator） 用意：用一个中介对象来封装一系列对象间的交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互。
设计模式专题之（十七）中介者模式--设计模式中介者模式示例代码(python--c++)
设计模式之建造者模式代码示例，
设计模式 - 中介者模式
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
c#设计模式之中介者，很好的。c#设计模式之中介者
创建模式: 设计模式之Factory 设计模式之Prototype(原型) 设计模式之Builder 设计模式之Singleton(单态) 结构模式: ...设计模式之Mediator(中介者) 设计模式之Interpreter(解释器) 设计模式之Visitor
1、爪哇语言结构性模式之变压器模式介绍 2、爪哇语言抽象工厂创立性模式介绍 3、工厂方法创立性模式介绍 4、单态创立性模式介绍 5、单态创立性模式介绍 6、观察者模式介绍7、责任链模式 8、设计模式之Observer 9、...
这个http://blog.csdn.net/dawanganban/article/details/9990405博客中java设计模式的源代码。下载前请先看《设计模式——建造者模式》一文。
设计模式之观察者模式，通过这个实例你就掌握观察者模式的原理和用法，值得学习。
设计模式之观察者模式Java版本实现和UML类设计图
java23中常用设计模式之建造者模式，详细源码分析请见： http://blog.csdn.net/github_22022001/article/details/42120867