简介

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

UML图

应用场景

• 大量的连接使得一个对象不可能在没有其他对象的支持下工作，系统表现为一个不可分割的整体
• 用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为而又不想生成太多的子类的场合

示例

联合国会议，用来处理世界各国的纠纷，联合国相当于中介者，各个国家在联合国进行谈判

1. Mediator:

public abstract class UnitedNations {

    /**
     * 声明
     *
     * @param message 消息
     */
    public abstract void declare(String message,Country country);
}

理事会

public class UnitedNationsCouncil extends UnitedNations {


    /**
     * 国家1
     */
    private USA colleague1;

    /**
     * 国家2
     */
    private Iraq colleague2;

    public void setColleague1(USA colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Iraq colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void declare(String message, Country country) {
        if (country == colleague1) {
            // 国家1给国家2带的话
            colleague2.getMessage(message);
        } else {
            colleague1.getMessage(message);
        }
    }
}

2. Colleague：国家

public abstract class Country {

    /**
     * 中介者
     */
    protected UnitedNations mediator;

    public Country(UnitedNations mediator) {
        this.mediator = mediator;
    }
}

public class Iraq extends Country {

    public Iraq(UnitedNations mediator) {
        super(mediator);
    }

    /**
     * 声明
     *
     * @param message
     */
    public void declare(String message) {
        mediator.declare(message, this);
    }

    /**
     * 获取信息
     *
     * @param message
     */
    public void getMessage(String message) {
        System.out.println("伊拉克得到对方的信息为：" + message);
    }
}

public class USA extends Country {


    public USA(UnitedNations mediator) {
        super(mediator);
    }

    /**
     * 声明
     *
     * @param message
     */
    public void declare(String message) {
        mediator.declare(message, this);
    }

    /**
     * 获取信息
     */
    public void getMessage(String message) {
        System.out.println("美国获取对方消息为：" + message);
    }
}

3. 运行

public class Main {

    public static void main(String[] args) {
        // 充当中介 联合国理事会
        UnitedNationsCouncil nationsCouncil = new UnitedNationsCouncil();

        // 都认识联合国
        USA usa = new USA(nationsCouncil);
        Iraq iraq = new Iraq(nationsCouncil);

        // 联合国认识两个国家
        nationsCouncil.setColleague1(usa);
        nationsCouncil.setColleague2(iraq);

        // 两个国家发表声明
        usa.declare("停止开发核武器，否则接受打击");
        iraq.declare("我们没有开发核武器，也不怕侵略！");

    }
}

总结

• 优点
  • 中介者的出现减少了Colleague之间的耦合，使得可以独立地改变和复用各个Colleague类和中介者
  • 由于把对象如何协作进行了抽象，将中介作为一个独立的改变并将其封装在一个对象中，将关注的对象从对象各自本身的行为转移到它们之间的交互上，可以从宏观角度去看待系统
• 缺点
  • 由于中介者对象过度的集中化可能导致其复杂性大大增加，导致理解难度增加和可维护性降低