Java中介者

假如有很多的对象联系很紧密，在没有中间者的情况下就会像下面这种方式：

那么有了中介者，就会变成以下这种方式：

先来看看中介者的定义：

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

中介者角色分析：

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

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

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

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

接下来我们就来实现一下中介者模式：

首先是抽象的同事类：

public abstract class Colleague {

    private Mediator mediator;

    private String name;

    Colleague(String name,Mediator mediator){
        this.name  =name;
        this.mediator = mediator;
    }

    public Mediator getMediator() {
        return mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 得到其他同事发来的信息
    public abstract void getMessage(String message,String messageFormName);

    // 与其他同事通信
    public abstract void contactColleague(String message,String ... toColleagueName);

}

具体的同事：

public class ColleagueImpl extends Colleague {


    ColleagueImpl(String name, Mediator mediator) {
        super(name, mediator);
    }

    @Override
    public void getMessage(String message,String messageFormName) {
        System.out.println("我" + this.getName() + " 被" + messageFormName + " 联系了， " + "信息为:" + message );
    }

    @Override
    public void contactColleague(String message,String ... toColleagueNames) {
        System.out.print("我 " + this.getName() + " 向 ");
        for (String toColleagueName : toColleagueNames){
            System.out.print(toColleagueName + ",");
        }
        System.out.println(" 发 " + message + " 信息");
        this.getMediator().contact(message,this, toColleagueNames);
    }

}

抽象的中介：

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

    /**
     * 中介者来使各同事之间的联系
     * @param content 交流内容
     * @param toColleagueNames 被联系者的名字
     */
    void contact(String content,Colleague colleague,String ... toColleagueNames);

    /**
     * 添加同事
     * @param colleague 被添加的同事
     */
    void addColleague(Colleague colleague);
}

具体的中介：

public class MediatorImpl implements Mediator {

    // 维护并知道所有同事。
    private Map<String,Colleague> colleagueMap = new HashMap<>();


    @Override
    public void contact(String message,Colleague colleagueForm, String... toColleagueNames) {
        for (String name : toColleagueNames){
            Colleague colleague = colleagueMap.get(name);
            colleague.getMessage(message,colleagueForm.getName());
        }
    }

    @Override
    public void addColleague(Colleague colleague) {
        this.colleagueMap.put(colleague.getName(),colleague);
    }
}

测试代码：

public class MediatorTest {
    public static void main(String[] args) {
        Mediator mediator = new MediatorImpl();

        Colleague colleagueA = new ColleagueImpl("小花",mediator);
        Colleague colleagueB = new ColleagueImpl("小明",mediator);
        Colleague colleagueC = new ColleagueImpl("小绿",mediator);
        Colleague colleagueD = new ColleagueImpl("小蓝",mediator);

        mediator.addColleague(colleagueA);
        mediator.addColleague(colleagueB);
        mediator.addColleague(colleagueC);
        mediator.addColleague(colleagueD);

        colleagueA.contactColleague("大家好",colleagueB.getName(),colleagueC.getName(),colleagueD.getName());
    }
}

测试结果：

我 小花 向 小明,小绿,小蓝, 发 大家好 信息
我小明 被小花 联系了， 信息为:大家好
我小绿 被小花 联系了， 信息为:大家好
我小蓝 被小花 联系了， 信息为:大家好

注意点：

中介要维护所有的已知的同事，同事是通过中介发信息。

总结：

优点：

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

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