中介者模式

中介者模式

案例引入

要求

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

传统方式实现案例

有闹钟类(Alarm)，电视类(TV)，窗帘类(Curtains)，咖啡机(Coffee Machine)，闹钟发消息给咖啡机，咖啡机发消息给窗帘，窗帘发消息给电视，来实现要求中的流程。
中介者模式和外观模式的区别，内部子系统是独立的。

传统方式问题分析

• 1.当各电器对象有多种状态改变时，相互之间的调用关系会比较复杂。
• 2.各个电器对象间彼此联系，相互依赖，不利于松耦合。
• 3.各个电器对象之间，所传递的消息多，很容易混乱。
• 4.当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性，扩展性都不理想 -> 考虑使用中介者模式。

中介者模式基本介绍

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

原理类图

角色分析

• 1.Mediator是抽象的中介者类。
• 2.Colleague是抽象的同事类，也可以看作是抽象的子系统的类。
• 3.ConcreteMediator具体的中介者对象，实现抽象方法，他需要知道所有的具体子系统类，并以一个HashMap集合的方式来管理所有的同事对象消息，完成相应的操作。
• 4.ConcreteColleague具体的同事类(子系统类)，会有很多，每个同事(子系统)只知道自己的行为，而不了解其他同事类(子系统)的行为(方法) 但是这些对象都依赖中介者对象。

中介者实现案例代码

/**
 * @author 长名06
 * @version 1.0
 * 中介者抽象类
 */
public abstract class Mediator {
    public abstract void register(String colleagueName,Colleague colleague);

    public abstract void getMessage(int stateChange,String colleagueName);

    public abstract void sendMessage();

}
/**
 * @author 长名06
 * @version 1.0
 * 具体的抽象者类
 */
public class ConcreteMediator extends Mediator{

    //hashMap集合，存储所有的子系统对象
    private HashMap<String,Colleague> colleagueMap;
    private HashMap<String,String> interMap;

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

    @Override
    public 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);
    }

    /**
     * 具体中介者的核心方法
     * @param stateChange
     * @param colleagueName
     */
    @Override
    public void getMessage(int stateChange, String colleagueName) {
        if(colleagueMap.get(colleagueName) instanceof Alarm){
            if(stateChange == 0){
                ((CoffeeMachine) colleagueMap.get(interMap.get("CoffeeMachine"))).startCoffee();
                ((TV)colleagueMap.get(interMap.get("TV"))).startTV();
            }else if(stateChange == 1){
                ((TV)colleagueMap.get(interMap.get("TV"))).stopTV();
            }
        } else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
            //TV发消息，代码没写全，理解这个思想即可
        }else if(colleagueMap.get(colleagueName) instanceof TV){

        }
    }

    @Override
    public void sendMessage() {

    }
}

/**
 * @author 长名06
 * @version 1.0
 * 子系统(同事)抽象类
 */
public abstract class Colleague {
    //持有中介者对象
    private Mediator mediator;
    //子系统name属性
    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);

}
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 CoffeeMachine extends Colleague{

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

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

    public void startCoffee(){
        System.out.println("开始做咖啡");
    }

    public void finishCoffee(){
        System.out.println("五分钟后");
        System.out.println("咖啡制作完成");
        sendMessage(0);
    }
}
public class TV extends Colleague{

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

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

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

    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.name);
    }
}
public class Client {
    public static void main(String[] args) {
        ConcreteMediator concreteMediator = new ConcreteMediator();

        //创建Alarm对象，并加入到 ConcreteMediator的hashMap中
        Alarm alarm = new Alarm(concreteMediator, "Alarm");
        CoffeeMachine coffeeMachine = new CoffeeMachine(concreteMediator,"CoffeeMachine");
        TV tV = new TV(concreteMediator, "TV");

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

注意事项和细节

• 1.多个类，相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦。
• 2.减少类间依赖，降低了耦合，符合迪米特法则。
• 3.中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响。
• 4.如果设计不当，中介者对象本身变得过于复杂，这点在使用时，需格外注意。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。