中介者模式

一、中介者模式介绍

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

二、中介者模式原理图

说明：

1）Mediator：就是抽象中介者，定义了同事对象到中介者对象的接口

2）Colleague：是抽象同事类

3）ConcreteMediator：具体的中介者对象，实现抽象方法，它需要知道所有的具体的同事类，即以一个集合来管理HashMap并接受某个同事对象消息，完成相应的任务

4）ConcreteColleague：具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为，但是它们都依赖中介者对象

三、中介者模式例子

       智能家庭项目：1）智能家庭包括各种设备：闹钟、咖啡机、电视机、窗帘等；2）主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹钟响起 -> 咖啡机开始做咖啡 -> 窗帘自动落下 -> 电视机开始播放

第一种设计方案：传统方案

传统方案问题分析：

1）当各个电器对象有多种状态改变，相互之间的调用关系会比较复杂

2）各个电器对象彼此联系，你中有我，我中有你，不利于松耦合

3）各个电器对象之间床底的消息，容易混乱

4）当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性、扩展性都不理想

第二种设计方案：使用中介者模式

类图如下所示：

中介者模式-智能家庭操作流程：

1）创建ConcreMediator对象

2）创建各个同事类对象，比如：Alarm、CoffeeMachine、TV...

3）在创建同事类对象的时候，就直接通过构造器加入到ColleagueMap

4）同事类对象，可以调用sendMessage，最终会去调用ConcreteMediator的getMessage方法

5）getMessage会根据接收到的同事对象发出的消息来协调调用其他的同事对象

6）可以看到getMessage是核心方法，完成相应任务

代码如下所示：

创建Colleague抽象类及其子类：

public abstract class Colleague{

    private Mediator mediator;
    private String name;

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

    public Mediator getMediator(){
        return mediator;
    }

    public abstract void sendMessage(int state);
}

public class Alarm extends Colleague{

    public Alarm(Mediator mediator, String name){
        //在创建alarm同事对象时，将自己放入到ConcreteMediator对象中
        mediator.register(name, this);
    }

    public void sendAlarm(int state){
        sendMessage(state);
    }

    public void sendMessage(int state){
        //调用中介者的getMessage
        this.getMediator().getMessage(state, this.name);
    }
}

public class CoffeeMechine extends Colleague{

    public CoffeeMechine(Mediator mediator, String name){
        //在创建CoffeeMechine 同事对象时，将自己放入到ConcreteMediator对象中
        mediator.register(name, this);
    }

    public void sendCoffeeMechine(int state){
        sendMessage(state);
    }

    public void sendMessage(int state){
        //调用中介者的getMessage
        this.getMediator().getMessage(state, this.name);
    }

    public void startCoffee(){}
}

public class Curtains extends Colleague{

    public Curtains(Mediator mediator, String name){
        //在创建Curtains同事对象时，将自己放入到ConcreteMediator对象中
        mediator.register(name, this);
    }

    public void sendCurtains(int state){
        sendMessage(state);
    }

    public void sendMessage(int state){
        //调用中介者的getMessage
        this.getMediator().getMessage(state, this.name);
    }

    public void upCurtains(){}

    public void downCurtains(){}
}

public class TV extends Colleague{

    public TV(Mediator mediator, String name){
        //在创建TV 同事对象时，将自己放入到ConcreteMediator对象中
        mediator.register(name, this);
    }

    public void sendTV(int state){
        sendMessage(state);
    }

    public void sendMessage(int state){
        //调用中介者的getMessage
        this.getMediator().getMessage(state, this.name);
    }

    public void startTV(){}

    public void stopTV(){}
}

创建Mediator抽象类及其子类：

public abstract class Mediator{

    //将中介者对象加入到集合中
    public abstract void register(String colleagueName, Colleague colleague);

    //接收消息，具体的同事对象发出
    public abstract void getMessage(int state, String colleagueName);

    public abstract void sendMessage();
}

public class ConcreteMediator extends Mediator{

    private HashMap<String, Colleague> colleagueMap;

    private HasMap<String, String> interMap;

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

    public void register(String colleagueName, Colleague colleague){
        colleagueMap.put(colleagueName, colleague);
        
        if(colleague instanceof Alram){
            interMap.put("Alram", colleagueName);
        } else if(colleague instanceof CoffeeMachine){
            interMap.put("CoffeeMachine", colleagueName);
        } else if(colleague instanceof TV){
            interMap.put("TV", colleagueName);
        } else if(colleague instanceof Curtains){
            interMap.put("Curtains", colleagueName);
        }
    }

    //具体中介者的核心方法
    //根据得到消息，完成对应任务
    //中介者在这个方法，协调各个具体的同事对象，完成任务
    public void getMessage(int state, int colleagueName){
        if(colleagueMap.get(colleagueName) instanceof Alram){
            if(state == 0){
                ((CoffeeMachine)(colleagueMap.get(interMap.get("CoffeeMachine")))).startCoffee();
                ((TV)(colleagueMap.get(interMap.get("TV")))).startTV();
            } else if(state == 1){
                ((TV)(colleagueMap.get(interMap.get("TV")))).stopTV();
            }
        } else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
            ((Curtains)(colleagueMap.get(interMap.get("Curtains")))).upCurtains();
        } else if(colleagueMap.get(colleagueName) instanceof TV){

        } else if(colleagueMap.get(colleagueName) instanceof Curtains){

        }
    }

}

创建Client类：

public class Client{

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

        Alarm alarm = new Alram(mediator, "alarm");

        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
        
        Curtains curtains = new Curtains(mdiator, "curtains");

        TV tv = new TV(mdiator, "TV");

        alarm.sendAlram(0);
    }
}

四、中介者模式的注意事项和细节

1）多个类相互耦合，会形成网状结构，使用中介者模式，将网状结构分离为星型结构，进行解耦

2）减少类间依赖，降低了耦合，符合迪米特原则

3）中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响

4）如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意