1.定义：
用一个中介对象封装一系列的对象交互，中介者使个对象不需要显示的相互作用，从而使其耦合松散，而且可以独立地改变他们之间的交互。
2.解析：
这段话不明白没关系，我们先来看这样的一个场景：
公司有1个领导，9个职员，有一天领导要去公司的图书馆找一本书，领导一看图书馆的这本书已经被借走了，他就去问职员1有没有拿走，如果没有就继续问职员2……终于领导找到了他想看的书。
在这个例子中最差的情况下，领导对象竟然要和9个职员对象进行耦合，从我们软件设计的角度来看是相当不合理的。
我们把上面这个故事抽象成一个简单的程序就编程了这样的代码：
package _8MediatorPattern;
public interface Staff {
public void borrowBook();
public boolean bookIsBorrowed();
}
package _8MediatorPattern;
import java.util.Date;
public class Leader implements Staff {
private Staff commonStaff;
@Override
public void borrowBook() {
// 先看书在不在小职员手里
if(commonStaff.bookIsBorrowed())
{
System.out.println("领导直接从图书馆借到了书！");
}else {
System.out.println("领导从小职员手里拿到了书，很简单！");
}
}
@Override
public boolean bookIsBorrowed() {
// 随机产生，书有没有被借走
return new Date().getTime()/2 == 0;
}
public Staff getCommonStaff() {
return commonStaff;
}
public void setCommonStaff(Staff commonStaff) {
this.commonStaff = commonStaff;
}
}
package _8MediatorPattern;
import java.util.Date;
public class CommonStaff implements Staff {
private Staff leader;
@Override
public void borrowBook() {
if(leader.bookIsBorrowed())
{
System.out.println("小员工直接从图书馆借到了书！");
}else {
System.out.println("小员工从领导手里借到了书，不容易！");
}
}
@Override
public boolean bookIsBorrowed() {
// 随机产生，书有没有被借走
return new Date().getTime()/2 == 0;
}
public Staff getLeader() {
return leader;
}
public void setLeader(Staff leader) {
this.leader = leader;
}
}
我们可以看到无论是职员还是领导，他们之间都相互耦合了。
现在上面这个故事我们继续：领导在借了三次书以后终于不耐烦，他决定给公司招一个图书管理员。那么他每次借书的时候只要跟管理员打招呼就行了：XXX，帮我把Java编程思想拿过来。然后管理员就去查询谁拿走了书，然后把书送到领导手里。
好了，我们讲到这里故事就结束了，因为中介者已经出现了。没错，这个管理员就是中介者。
3.中介者模式的结构（中介者模式又称为调停者模式）
- 抽象中介者：抽象中介者角色定义统一的接口，用于各同事角色之间的通信。
- 具体中介者：具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖各个同事角色。
- 同事角色：每个同事角色都知道中介者角色 ，而且与其他的同事角色通信的时候，一定通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种方法叫做自发行为，与其他同事类或者中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法。
4.中介者模式通用代码：
package _8MediatorPattern;
/**
* 通用抽象中介者
*/
public abstract class Mediator {
// 定义同事类
protected ConcreteColleage1 colleage1;
protected ConcreteColleage2 colleage2;
// 中介者模式的业务逻辑（依赖关系复杂的)
public abstract void doSomething1();
public abstract void doSomething2();
public ConcreteColleage1 getColleage1() {
return colleage1;
}
public void setColleage1(ConcreteColleage1 colleage1) {
this.colleage1 = colleage1;
}
public ConcreteColleage2 getColleage2() {
return colleage2;
}
public void setColleage2(ConcreteColleage2 colleage2) {
this.colleage2 = colleage2;
}
}
package _8MediatorPattern;
/**
* 中介者具体类
*/
public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
super.colleage1.selfMethod1();
// 依赖方法
super.colleage2.depMethod2();
}
@Override
public void doSomething2() {
// 依赖方法
super.colleage1.depMethod1();
super.colleage2.selfMethod2();
}
}
package _8MediatorPattern;
/**
* 抽象同事类
*/
public abstract class Colleage {
protected Mediator mediator;
public Colleage(Mediator mediator)
{
this.mediator = mediator;
}
}
package _8MediatorPattern;
/**
* 同事类1
*/
public class ConcreteColleage1 extends Colleage {
// 通过构造函数传递中介者
public ConcreteColleage1(Mediator mediator) {
super(mediator);
}
// 自有方法 self-method
public void selfMethod1()
{
}
// 依赖方法 dep-method
public void depMethod1()
{
super.mediator.doSomething1();
}
}
package _8MediatorPattern;
/**
* 同事类2
*/
public class ConcreteColleage2 extends Colleage {
// 通过构造函数传递中介者
public ConcreteColleage2(Mediator mediator) {
super(mediator);
}
// 自有方法 self-method
public void selfMethod2()
{
}
// 依赖方法 dep-method
public void depMethod2()
{
super.mediator.doSomething2();
}
}
5.中介者模式的使用场景：
中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。
中介者模式虽然简单，但不代表易用。在OOP中对象必然会存在依赖关系，中介者模式未必能把原来凌乱的逻辑整理的清清楚楚，而且中介者模式也是有缺点的，使用不当，缺点会被无限放大。
6.中介者模式的优点：
中介者模式的优点就是减少类间的依赖，把原本的一对多依赖编程了一对一依赖，同事类只依赖中介者，减少了依赖，同事也降低了类间的耦合。
7.中介者模式的缺点：
中介者模式的缺点是中介者会膨胀的很大，而且逻辑复杂，原本N个对象直接相互依赖的关系转换成了中介者和同事类的依赖关系，同事类越多，中介者的逻辑越复杂。
8.中介者模式的实际应用：
- 机场的调度中心
- MVC框架中的Controller
- 媒体网关，比如QQ的聊天服务器
- 中介服务，比如房产中介