定义

中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而可以使他们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。从而保证这些作用可以彼此独立变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

使用场景

当对象之间的交互操作很多且每个对象的行为操作都彼此依赖时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可采用中介者模式来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

关键点

抽象中介者角色，定义一个抽象接口方法，具体的事物类通过该方法来通知中介者自身的状态改变

具体中介者角色，继承于抽象中介者，从具体事物对象接受消息，向具体的事物发出命令

抽象事物角色，定义了中介者对象的接口，只知道中介者，不知道其他的事物对象

具体事物角色，继承于抽象事物角色，每个具体的事物类都知道本身在小范围内的行为，但不知道它在大范围内的角色

实现

/**
 * 抽象中介者
 */
public abstract class AbsMediator {

    public abstract void change(AbsRole role);

}

/**
 * 抽象事物角色_持有抽象中介者引用
 */
public abstract class AbsRole {

    protected AbsMediator mediator;

    public AbsRole(AbsMediator absMediator) {
        this.mediator = absMediator;
    }
}

/**
 * 具体中介者_持有互相关联的具体事物对象
 */
public class ConcreteMediaor extends AbsMediator {

    private RoleA roleA;
    private RoleB roleB;

    @Override
    public void change(AbsRole role) {
        if (role == roleA) {
            //在这里进行roleA改变时其他数据的改变操作
        } else if (role == roleB) {
            //在这里进行roleB改变时其他数据的改变操作
        }
    }

    /**
     * 注入具体事物A
     */
    public void setRoleA(RoleA roleA) {
        this.roleA = roleA;
    }

    /**
     * 注入具体事物B
     */
    public void setRoleB(RoleB roleB) {
        this.roleB = roleB;
    }
}

/**
 * 具体事物A
 */
public class RoleA extends AbsRole {

    public RoleA(AbsMediator absMediator) {
        super(absMediator);
    }

    /**
     * 具体事物A变化_通知中介者改变其他相关事物
     */
    public void changeRoleA() {
        mediator.change(this);
    }
}

/**
 * 具体事物B
 */
public class RoleB extends AbsRole {

    public RoleB(AbsMediator absMediator) {
        super(absMediator);
    }

    /**
     * 具体事物B变化_通知中介者改变其他相关事物
     */
    public void changeRoleA() {
        mediator.change(this);
    }
}

使用

ConcreteMediator mediator = new ConcreteMediator();

//创建具体事物，并与中介者关联
RoleA roleA = new RoleA(mediator);
RoleB roleB = new RoleB(mediator);

//将事物注入到中介者
mediator.setRoleA(roleA);
mediator.setRoleB(roleB);

//假设事物B改变
roleB.changeRoleB();

小结

优点

对复杂的依赖关系进行解耦，从而逻辑结构变得清晰，维护性和扩展性极高

缺点

类数量增多