【Java设计模式】：行为型模式—中介者模式

1. 中介者模式(Mediator pattern)定义

使用中介者模式来集中相关对象之间复杂的沟通和控制方式，使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2. 中介者的作用

如下图所示，此图中有6个对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事（Colleague）对象。这些同事对象通过彼此的相互作用形成系统的行为。从图中可以看出，当对象1改变时，除了对象3之外其他所有对象都有可能受到影响；当对象2改变时，所有对象都有可能受到影响。这就是过度耦合的系统。

通过引入中介者（Mediator），那么同事类之间的关系将变成星型结构。如下图所示，在这个星型结构中，同事对象不再通过直接的联系与另一个对象发生相互作用；相反的，它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入造成大量的修改工作。

3. 中介者模式的结构

类图：

角色说明：

• 抽象中介者角色（AbstractMediator）：定义出同事对象到中介者对象的接口，其中主要方法是一个（或多个）事件方法。

• 具体中介者角色（ConcreteMediator）：实现抽象中介者中所声明的事件方法。具体中介者直销所有的具体同事类，并负责具体的协调各个同事对象的交互关系。

• 抽象同事类角色（AbstractColleague）：定义出红接着到同事对象的接口。同事对象只知道中介者，而不知道其余的同事对象。

• 具体同事类角色（ConcreteColleague）：所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同时交互。

4. 代码演示

抽象中介者：

public interface AbstractMediator {

    //中介者通过此方法来改变同事B
    public void aChangedB(String str);

    //中介者通过此方法来改变同事A
    public void bChangedA(String str);
}

抽象同事类：

public abstract class AbstractColleague {

    //同事对象在改变的时候，通知中介者，并传递影响值
    public abstract void setString(String str, AbstractMediator am);

    //同事对象提供一个接口接收中介者传递的影响值
    public abstract void changeString(String str);
}

具体同事类A：

public class ConcreteColleagueA extends AbstractColleague {
    // 同事A的字符串属性
    private String strAttribute;

    // 构造函数，构造字符串属性
    public ConcreteColleagueA(String str) {
        this.strAttribute = str;
    }

    /**
     * 被改变的函数
     */
    @Override
    public void changeString(String str) {
        this.strAttribute = this.strAttribute + "这是同事B对我的影响：" + str;

    }

    /**
     * 改变时，通知中介者改变其他同事
     */
    @Override
    public void setString(String str, AbstractMediator am) {
        am.aChangedB(str);
    }

    public String getStrAttribute() {
        return strAttribute;
    }

}

具体同事类B：

public class ConcreteColleagueB extends AbstractColleague {
    private String strAttribute;

    public ConcreteColleagueB(String str) {
        this.strAttribute = str;
    }

    @Override
    public void changeString(String str) {
        this.strAttribute = this.strAttribute + "这是同事A对我的影响：" + str;

    }

    @Override
    public void setString(String str, AbstractMediator am) {
        am.bChangedA(str);
    }

    public String getStrAttribute() {
        return strAttribute;
    }
}

具体中介者类：

public class ConcreteMediator implements AbstractMediator {
    // 持有并维护同事A
    private ConcreteColleagueA colleagueA;
    // 持有并维护同事B
    private ConcreteColleagueB colleagueB;

    // 传入同事A的对象
    public void setColleagueA(ConcreteColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    // 传入同事B的对象
    public void setColleagueB(ConcreteColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    /**
     * 收到同事A的改变，通知同事B改变
     */
    @Override
    public void aChangedB(String str) {
        colleagueB.changeString(str);

    }

    /**
     * 收到同事B的改变，通知同事A改变
     */
    @Override
    public void bChangedA(String str) {
        colleagueA.changeString(str);

    }

}

客户端测试类：

public class Client {

    public static void main(String[] args) {
        // 实例化同事A、B
        ConcreteColleagueA colleagueA = new ConcreteColleagueA("大家好，我是同事A。");
        ConcreteColleagueB colleagueB = new ConcreteColleagueB("大家好，我是同事B。");

        // 同时把同事A、B传入给中介者
        ConcreteMediator am = new ConcreteMediator();
        am.setColleagueA(colleagueA);
        am.setColleagueB(colleagueB);

        // 同事A影响同事B
        System.out.println(colleagueB.getStrAttribute());
        colleagueA.setString("同事A传递给同事B的值", am);
        System.out.println(colleagueB.getStrAttribute());

        System.out.println("==========================");

        // 同事B影响同事A
        System.out.println(colleagueA.getStrAttribute());
        colleagueB.setString("同事B传递给同事A的值", am);
        System.out.println(colleagueA.getStrAttribute());
    }

}

运行结果：

5. 中介者模式的优缺点：

中介者模式的优点：

• 使用中介者模式可以把对个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合。
• 中介者模式可以将原先多对多的同事对象关系变成中介者对象一对多同事对象的关系，这样会让对象之间的关系更容易理解和实现。
• 同事对象之间的交互都被封装到中介者对象里面集中管理，集中了控制交互。当交互发生改变时，着重修改的是中介者对象。当需要扩展中介者对象时，其他同事对象不需要做修改。

缺点：

• 过度集中化，这是中介者模式潜在的缺点。如果同事对象多了，交互也复杂了。那么这些交互全部集中到中介者对象中，会导致中介者对象十分臃肿，难以管理和维护。

参考原文： https://blog.csdn.net/jsagacity/article/details/79032608