学习笔记【23种设计模式-第十八节：Mediator Pattern 中介者模式】

Mediator Pattern 中介者模式

简述：

• 中介者模式，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示的相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
• 中介者模式属于行为型模式，使代码易于维护
• 比如MVC模式，C（Controller控制器）是M（Model模型）和V（View视图）的中介者，在前后端交互时起到了中间人的作用。

角色

• Mediator就是抽象中介者，它定义了同事对象到中介者对象的接口
• Colleague 是抽象同事类
• ConcreteMediator是一个具体的中介者对象，实现抽象方法，它需要知道所有的同事类，一般以集合管理，并接受某个同事对象的消息，完成相应的任务。
• ConcreteColleague 是具体的同事类，会有很多，每个同事只知道自己的行为，不了解其他同事类的信息，他们都会依赖中介者对象。

例子

智能家庭：Mediator抽象中介类，有一个ConcreteMediator类继承它，其中有一个HashMap，有getMessage来接受同事信息。Colleague抽象类中有sendMessage，getMediator返回中介者Mediator的方法。有TV、Alarm、CoffeeMachine、Curtains类来继承继承同事类。

Mediator抽象中介类：

public abstract class Mediator {
    //加入到集合中
    public abstract void Register(String colleagueName,Colleague colleague);
    //接收信息，具体的同事对象发出
    public abstract void getMessage(int stateChange,String colleagueName);

    public abstract void sendMessage();
}

Colleague抽象类：

public abstract class Colleague {
    private Mediator mediator;
    public String name;

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

    public Mediator getMediator(){
        return mediator;
    }

    public abstract void sendMessage(int stateChange);
}

TV、Alarm、CoffeeMachine、Curtains类（大同小异，拿Alarm举例，其中有些方法就不写了）：

public class Alarm extends Colleague {
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        //在创建Alarm对象时，就将自己放入到ConcreteMediator对象的集合中
        mediator.Register(name,this);
    }

    public void sendAlarm(int stateChange){
        sendMessage(stateChange);
    }
    @Override
    public void sendMessage(int stateChange) {
        getMediator().getMessage(stateChange,name);

    }
}

ConcreteMediator类（方法没有写完，大概就是这样一层一层的判断）：

public class ConcreteMediator extends Mediator{
    private HashMap<String,Colleague> colleagueHashMap;
    private HashMap<String,String> interMap;

    public ConcreteMediator() {
        colleagueHashMap=new HashMap<>();
        interMap=new HashMap<>();
    }

    @Override
    public void Register(String colleagueName, Colleague colleague) {
        colleagueHashMap.put(colleagueName,colleague);

        if (colleague instanceof Alarm) interMap.put("Alarm",colleagueName);
        else if (colleague instanceof TV) interMap.put("TV",colleagueName);
        else if (colleague instanceof CoffeeMachine) interMap.put("CoffeeMachine",colleagueName);
        else if (colleague instanceof Curtains) interMap.put("Curtains",colleagueName);

    }

    @Override
    public void getMessage(int stateChange, String colleagueName) {
        if (colleagueHashMap.get(colleagueName) instanceof Alarm){
            if (stateChange==0){
                ((CoffeeMachine)( colleagueHashMap.get(interMap.get("CoffeeMachine")))).
            }
        }
    }

    @Override
    public void sendMessage() {

    }
}

注意事项

• 多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦。
• 减少类间依赖，降低耦合，符合迪米特原则。
• 中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响。
• 如果设计不当，中介者本身变得过于复杂，这点在实际使用时，要特别注意。