设计模式-18中介者模式

中介者模式

基本介绍：

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

原理类图：

角色说明：

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

案例：

需求：

​ 完成前面的只能家居项目

类图：

public abstract class Mediator {
    //将中介者对象加入到集合中
    abstract void register(String colleagueName,Colleague colleague);
    //接收消息，具体的同事类发出
    abstract void getMessage(int stateChange,String colleagueName);
    abstract void  sendMessage();
}

public class ConcreteMediator extends Mediator {

    private Map<String,Colleague> colleagueMap;
    private Map<String,String> interMap;

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

    @Override
    void register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName,colleague);

        if(colleague instanceof Alarm){
            interMap.put("Alarm",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);
        }
    }

    /**
     * 具体中介者核心方法
     * 1.根据得到的消息完成对应的任务
     * 2.中介者在这个方法协调各个具体的同事对象完成任务
     */
    @Override
    void getMessage(int stateChange, String colleagueName) {
        if(colleagueMap.get(colleagueName) instanceof Alarm){
            if(stateChange == 0){
                ((CoffeeMachine)colleagueMap.get(interMap.get("CoffeeMachine"))).start();
                ((Tv)colleagueMap.get(interMap.get("Tv"))).start();
            }else if(stateChange == 1){
                ((Tv)colleagueMap.get(interMap.get("Tv"))).stop();
            }
        }else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
            ((Curtains)colleagueMap.get(interMap.get("Curtains"))).up();
        } else if(colleagueMap.get(colleagueName) instanceof Tv){
            //空实现
        } else if(colleagueMap.get(colleagueName) instanceof Curtains){

        }
    }

    @Override
    void sendMessage() {

    }
}

/**
 * 抽象类
 */
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 this.mediator;
    }

    public abstract void sendMessage(int stateChange);
}


/**
 * Created by xys1917 on 2020/3/8.
 * 具体的同事类
 */
public class Alarm extends Colleague {

    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }
    public void sendAlarm(int stateChange){
        sendMessage(stateChange);
    }
    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.name);
    }
}

public class Curtains extends Colleague {

    public Curtains(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    public void up(){
        System.out.println("窗帘升起");
    }

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

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

public class Tv extends Colleague {

    public Tv(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    public void start(){
        System.out.println("打开电视");
    }

    public void stop(){
        System.out.println("关闭电视");
    }

    public void sendTv(int stateChange){
        sendMessage(stateChange);
    }

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

public class CoffeeMachine extends Colleague {

    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    public void start(){
        System.out.println("打开咖啡机");
    }

    public void sendCoffeeMachine(int stateChange){
        sendMessage(stateChange);
    }

    public  void finishCoffee(){
        System.out.println("咖啡制作完毕");
    }

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

public class Client {

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

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

        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");

        Curtains curtains = new Curtains(mediator, "curtains");

        Tv tv = new Tv(mediator, "Tv");

        alarm.sendAlarm(0);
        coffeeMachine.finishCoffee();
        alarm.sendAlarm(1);
    }
}

流程说明：

• 创建ConcreteMediator对象
• 创建各个具体的同事类，比如：alarm、Tv
• 创建各个同事对象的时候，就直接通过构造器，加入到ColleagueMap
• 同事类对象，可以使用sendMessage，最终会调用ConcreteMediator的getMessage方法
• getMessage会根据接收到的同事对象发出的消息来协调调用其他同事对象完成任务
• 可以看到getMessage是核心方法，完成相应任务

中介者模式注意事项和细节：

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