java设计模式-中介者模式

java设计模式-中介者模式

首先引出一个需求
智能家庭项目:

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

2)主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流

程为:闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放

如果传统方案解决

传统的方式的问题分析

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

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

3. 各个电器对象之间所传递的消息(参数)，容易混乱

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

都不理想→考虑中介者模式

比如 同事之间的相互依赖关系

用中介者模式之后

把同事之间的逻辑交给中介处理

基本介绍

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

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

3. 比如MVC模式，c (Controller控制器）是M (Model模型）和v (View视图）的中介者，在前后端交互时起到了中间人的作用
   
   中介者模式类图
   
   对于类图的说明

• [ ]

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

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 colleagueName);
    public abstract 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);
}

具体的同事

//闹钟  具体的同事类
public class Alarm extends Colleague {
    
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        //在创建 Alarm 同事对象时，将自己放入到 ConcreteMediator 对象中[集合]
        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 void qichaung(){
        System.out.println("起床");
    }
    public void xuexi(){
        System.out.println("学习");
    }
}

具体的咖啡类 同事类

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("It's time to startcoffee!");
    }
    public void FinishCoffee() {
        System.out.println("After 5 minutes!");
        System.out.println("Coffee is ok!");
        SendMessage(0);
    }
}

具体的中介者 核心

public class ConcreteMediator extends Mediator{

    //集合放入所有的同事对象
    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);
    }

    //具体中介者核心方法
    //1.根据得到消息，完成对应任务
    //2.中介者在这个方法，协调各个具体的同事对象，完成任务

    @Override
    public void GetMessage(int stateChange, String colleagueName) {
        //传入的如果是Alarm  则处理相应方法
        if (colleagueMap.get(colleagueName) instanceof Alarm){
            if (stateChange==0){
                ((Alarm) colleagueMap.get(colleagueName)).qichaung();
            }else if (stateChange==1){
                ((Alarm) colleagueMap.get(colleagueName)).xuexi();
            }
            //TV相应的方法
        }else if(colleagueMap.get(colleagueName) instanceof TV){
            if (stateChange==0){
                ((TV) colleagueMap.get(colleagueName)).StartTv();
            }else if (stateChange==1){
                ((TV) colleagueMap.get(colleagueName)).StopTv();
            }
            //Curtains相应的方法
        }else if (colleagueMap.get(colleagueName) instanceof Curtains){
            if (stateChange==0){
                ((Curtains) colleagueMap.get(colleagueName)).UpCurtains();
            }
            //Coffe相应的方法
        }else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine){
            if (stateChange==0){
                ((CoffeeMachine) colleagueMap.get(colleagueName)).StartCoffee();
            }else if (stateChange==1){
                ((CoffeeMachine) colleagueMap.get(colleagueName)).FinishCoffee();
            }
        }
    }

    @Override
    public void SendMessage() {

    }
}

测试类

public static void main(String[] args) {
    //创建中介者
        ConcreteMediator 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");

        //让闹钟发送消息   实则是调用自己组合的中介者调用自己的方法
        tv.SendMessage(0);
        //开咖啡机
        coffeeMachine.SendMessage(0);
        coffeeMachine.SendMessage(1);
        //关窗帘
        curtains.SendMessage(0);
        //响闹钟 去学习
        alarm.SendMessage(1);

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

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

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

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

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