1.概述
定义为，用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。通用类图如下：
中介者模式有以下模块组成：
Mediator 抽象中介者
ConcreteMediator具体中介者
Colleague同事类
2.优缺点
中介者优点就是减少了类间的依赖，把原来同事类之间的相互依赖变成了每个同事类只是依赖中介者，降低了类间的耦合。
缺点就是随着业务的增多中介者会变得越来越大，越来越复杂。
3.实际应用
中介者模式也叫作调停者模式，一个对象和多个对象交流，自己作为中心，来负责多个类之间的交流。
机场调度中心：飞机、跑道、航线之间调度
mcv框架：controller将model和view隔离开
媒体网关：用户之间的消息经过MSN服务器中转
中介服务：各种房屋中介，不用一个一个小区找，找中介，具体交个中介去处理，房东也只和中介沟通就行了。
4.代码示例
创建中介者抽象类，它依赖同事类
/**
* @author chiangtaol
* @date 2020-12-02
* @describe 抽象中介者
*/
@Data
public abstract class MediatorAbstract {
protected ConcreteColleague1 colleague1;
protected ConcreteColleague2 colleague2;
public MediatorAbstract(){
this.colleague1 = new ConcreteColleague1(this);
this.colleague2 = new ConcreteColleague2(this);
}
// 中介者能做的事情
public abstract void doSomething1();
public abstract void doSomething2();
}创建具体的中介，一般只有一个中介者实现类，由一个中介实现所有抽象方法。
/**
* @author chiangtaol
* @date 2020-12-02
* @describe 具体中介者
*/
public class ConcreteMediator extends MediatorAbstract{
@Override
public void doSomething1() {
// 可用调用同事的方法
super.colleague1.selfMethod1();
super.colleague2.selfMethod2();
}
@Override
public void doSomething2() {
System.out.println("这是同事单独做不到的事情,这里可以调用到所有同事public方法,省去了同事间的相互调用");
}
}创建同事的抽象类，规定构造方法参数必须传入一个中介者
/**
* @author chiangtaol
* @date 2020-12-02
* @describe 同事抽象类
*/
public abstract class ColleagueAbstract {
protected MediatorAbstract mediatorAbstract;
public ColleagueAbstract(MediatorAbstract mediator){
this.mediatorAbstract = mediator;
}
}创建具体的同事类，每个类都有自己能做到的事情，不能做到的事交个中介去做，中介依赖了其他同事类，每个同事只需依赖中介就行了，具体实现在具体中介类中完成。
/**
* @author chiangtaol
* @date 2020-12-02
* @describe 具体同事类, 有特定职能
*/
public class ConcreteColleague1 extends ColleagueAbstract{
// 通过构造方法传递中介类
public ConcreteColleague1(MediatorAbstract mediator) {
super(mediator);
}
/**
* 自己能做的事情
*/
public void selfMethod1(){
System.out.println("这是同事1能做到的事情");
}
/**
* 自己做不到的事情,需要委托中介办理
*/
public void depMethod1(){
super.mediatorAbstract.doSomething1();
}
}/**
* @author chiangtaol
* @date 2020-12-02
* @describe 同事类
*/
public class ConcreteColleague2 extends ColleagueAbstract{
// 通过构造方法传递中介
public ConcreteColleague2(MediatorAbstract mediator) {
super(mediator);
}
/**
* 自己能做的事情
*/
public void selfMethod2(){
System.out.println("这是同事2能做到的事情");
}
/**
* 自己做不到的事情,需要委托中介办理
*/
public void depMethod2(){
super.mediatorAbstract.doSomething2();
}
}class ConcreteMediatorTest {
@Test
public void test() throws Exception{
// 中介者
ConcreteMediator mediator = new ConcreteMediator();
// 同事1
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
// 调用自己能做到的
colleague1.selfMethod1();
System.out.println("------------------------");
// 委托中介去办,调用自己和同事2能办的事情
colleague1.depMethod1();
System.out.println("------------------------");
// 同事2
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
// 调用自己的方法
colleague2.selfMethod2();
System.out.println("------------------------");
// 委托中介去办的事情
colleague2.depMethod2();
}
}
这是同事1能做到的事情
------------------------
这是同事1能做到的事情
这是同事2能做到的事情
------------------------
这是同事2能做到的事情
------------------------
这是同事单独做不到的事情,这里可以调用到所有同事public方法,省去了同事间的相互调用