设计模式之中介者模式

基本介绍

当多个对象状态发生改变时，相互之间的调用关系会比较复杂

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

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

角色及职责

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

示例代码

Mediator：

public abstract class Mediator {
    /**
     * 将中介者对象加入到集合中
     * @param name
     * @param tv
     */
    public abstract void register(String name, Colleague tv);

    /**
     * 接收消息，具体的同事对象发出
     * @param stateStatus
     * @param colleagueName
     */
    public abstract void getMessage(int stateStatus,String colleagueName);
    public abstract void sendMessage();
}

Colleague

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

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

    public Mediator getMediator() {
        return mediator;
    }

    public abstract void sendMessage(int stateStatus);

}

ConcreteMediator

public class ConcreteMediator extends Mediator{

    private HashMap<String ,Colleague> colleagueHashMap;
    private HashMap<String ,String> interMap;

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

    @Override
    public void register(String name, Colleague colleague) {
        colleagueHashMap.put(name,colleague);

        if (colleague instanceof Alarm){
            interMap.put("alarm",name);
        }else if (colleague instanceof CoffeeMachine){
            interMap.put("CoffeeMachine",name);
        }else if (colleague instanceof TV){
            interMap.put("TV",name);
        }else if (colleague instanceof Curtains){
            interMap.put("Curtains",name);
        }
    }

    /**
     * 具体中介者的核心方法
     * 根据得到的消息完成对应的任务
     * 中介者在这个方法中协调各个具体的同事类完成任务
     * @param stateStatus
     * @param colleagueName
     */
    @Override
    public void getMessage(int stateStatus, String colleagueName) {
        if (colleagueHashMap.get(colleagueName) instanceof Alarm){
            if (stateStatus == 0){
                ((CoffeeMachine) (colleagueHashMap.get(interMap.get("CoffeeMachine")))).startCoffee();
                ((TV) (colleagueHashMap.get(interMap.get("TV")))).startTV();
            }else if (stateStatus == 1){
                ((TV) (colleagueHashMap.get(interMap.get("TV")))).startTV();
            }
        }else if (colleagueHashMap.get(colleagueName) instanceof CoffeeMachine){
            ((Curtains) (colleagueHashMap.get(interMap.get("Curtains")))).upCurtains();
        }else if (colleagueHashMap.get(colleagueName) instanceof TV){

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

        }
    }

    @Override
    public void sendMessage() {

    }
}

ConcreteColleague:

public class TV extends Colleague{
    public TV(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

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

    public void startTV(){
        System.out.println("启动电视");
    }
}

public class Alarm extends Colleague{


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

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

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

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

    public void startCoffee(){
        System.out.println("启动咖啡机");
    }
}

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

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

    public void upCurtains(){
        System.out.println("挂起窗帘");
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        // 创建一个Alarm
        Alarm alarm = new Alarm(mediator,"alarm");
        // 创建coffeeMachine
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator,"coffeeMachine");
        // 创建TV
        TV tv = new TV(mediator,"TV");
        // 发送消息
        alarm.sendMessage(0);
    }
}

注意事项和细节

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