概述

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

为什么要使用中介者模式

一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下图中，有六个同事类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，同事类之间直接关联的设计是不好的。

如果引入中介者模式，那么同事类之间的关系将变为星型结构，从图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会把所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

中介者模式的结构

源代码

/**
 * 抽象的中介者类
 */
public interface Mediator {

    public void change(Colleague colleague);

}

/**
 * 具体的中介者
 */
public class ConcreteMediator implements Mediator {

    //中介者需要知道所有的具体的同事类
    private Colleague concreteColleagueA;
    private Colleague concreteColleagueB;

    public void setConcreteColleagueA(Colleague concreteColleagueA) {
        this.concreteColleagueA = concreteColleagueA;
    }

    public void setConcreteColleagueB(Colleague concreteColleagueB) {
        this.concreteColleagueB = concreteColleagueB;
    }

    /**
     * 当某一个同事类发生变化，需要通知其他的同事类来实现协助行为
     * @param colleague
     */
    @Override
    public void change(Colleague colleague) {
        if(colleague == concreteColleagueA){
            System.out.println("同事类A发生了变化，需要B协助");
            concreteColleagueB.doHelp();

        }else if(colleague == concreteColleagueB){
            System.out.println("同事类B发生了变化，需要A协助");
            concreteColleagueA.doHelp();
        }
    }
}

/**
 * 抽象的同事类
 */
public abstract class Colleague {

    //持有一个中介者对象
    private Mediator mediator;

    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

    //获取中介者对象
    public Mediator getMediator() {
        return mediator;
    }

    //执行某些操作时，需要通知中介者，让中介者去调用被影响的其他同事类
    public abstract void operate();

    //当某一个同事类发生变化时协助其变化
    public abstract void doHelp();
}

/**
 * 具体的同事类
 */
public class ConcreteColleagueA extends Colleague {

    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void doHelp() {
        System.out.println("同事类A正在协助");
    }

    /**
     * 执行某些操作时，需要通知中介者，让中介者去调用被影响的其他同事类
     */
    public void operate(){
        getMediator().change(this);
    }
}

/**
 * 具体的同事类
 */
public class ConcreteColleagueB extends Colleague {

    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void doHelp() {
        System.out.println("同事类B正在协助");
    }

    /**
     * 执行某些操作时，需要通知中介者，让中介者去调用被影响的其他同事类
     */
    public void operate(){
        getMediator().change(this);
    }
}

/**
 * 客户端
 */
public class Client {

    public static void main(String[] args) {
        //创建中介者
        ConcreteMediator mediator = new ConcreteMediator();

        //创建同事类
        Colleague colleagueA = new ConcreteColleagueA(mediator);
        Colleague colleagueB = new ConcreteColleagueB(mediator);

        //让中介者知道所有的同事
        mediator.setConcreteColleagueA(colleagueA);
        mediator.setConcreteColleagueB(colleagueB);

        //同事类A变化
        colleagueA.operate();
        System.out.println("------------");

        //同事类B变化
        colleagueB.operate();

    }

}

中介者模式的优点

●　　松散耦合

中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。

●　　集中控制交互

多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了，当然如果是已经做好的系统，那么就扩展中介者对象，而各个同事类不需要做修改。

●　　多对多变成一对多

没有使用中介者模式的时候，同事对象之间的关系通常是多对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。

中介者模式的缺点

中介者模式的一个潜在缺点是，过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到中介者的时候，会导致中介者对象变得十分复杂，而且难于管理和维护。