中介者模式

1、天气预报项目需求

1）智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等。

2）主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。

【普通解决方案】

闹钟类发送消息给咖啡机类，咖啡机类启动后通知窗帘类，窗帘类落下后通知TV类。

【方案问题分析】

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

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

3）各个电器对象之间所传递的消息（参数），容易混乱。

4）当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性、扩展性都不理想，所以要考虑使用中介者模式。

2、中介者模式的基本介绍

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

2）中介者模式属于行为型模式，使代码易于维护。

3）比如MVC模式，Controller是Model和View的中介者，在前后端交互时起到了中间人的作用。

【中介者模式的角色及职责】

抽象中介者（Mediator）角色：定义了同事对象到中介者对象的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
具体中介者（ConcreteMediator）角色：实现中介者接口，实现抽象方法。他需要知道所有的具体的同事类，即以一个集合HashMap / List来管理，并接受某个同事对象消息，完成相应的任务。
抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
具体的同事类（ConcreteColleague）角色：是抽象同事类的实现者，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为（方法），但是他们都依赖中介者对象。当需要与其他同事对象交互时，由中介者对象负责后续的交互。

3、应用实例代码实现

【智能家庭的操作流程】

1）创建ConcreMediator对象。

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

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

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

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

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

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

// 具体的中介者类
public class ConcreteMediator extends Mediator {
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;
    
    public ConcreteMediator() {
        colleague = new HashMap();
        interMap = new HashMap();
    }
    
    @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);  
        } else if (colleague instanceof Curtains) {
            interMap.put("Curtains", 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) {
            
        } else if (colleagueMap.get(colleagueName) instanceof TV) {
            
        } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
            
        }
    }
}

// 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 this.mediator;
    }
    
    public abstract void sendMessage(int stateChange);
}

// 同事类
public class Alarm extends Colleague {
    public Alarm(Mediator mediator, String name) {
        // 在创建Alarm同事对象时，将自己放入到ConcreteMediator对象中
        super(mediator, name);
        mediator.Register(name, this);
    }
    
    public void SendAlarm(int stateChange) {
        SendMessage(stateChange);
    }
    
    @Override
    public void SendMessage(int stateChange) {
        // 调用的中介者对象的getMessage
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}

public class CoffeeMachine extends Colleague {
    ...
    
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    
    public void StartCoffee() {
        System.out.println("It's time to startcoffee!");
    }
    
    public void FinishCoffee() {
        System.out.println("After 5 minutes!");
        System.out.println("Coffee is ok!");
        SendMessage(0);
    }
}

public class Curtains extends Colleague {
    public Curtains(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }
    
    public void UpCurtains() {
        System.out.println("I am holding Up Curtains");
    }
    
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}

public class TV extends Colleague {
    public TV(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 StartTv() {
        System.out.println("It's time to StartTv!");
    }
    
    public void StopTv() {
		System.out.println("It's time to StopTv!");
    }
}

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);
    }
}