设计模式（十五）之行为型模式-中介者模式

发表于 | 阅读次数:
字数统计: 1.7k | 阅读时长 ≈ 7

一、中介者模式

1、案例讲解

1.1 智能家庭项目

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

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

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

1.2 传统方法类图

客户想要租房，找到房东，房东可能要去妻子、爸爸等去交流，然后都同意，在出租，比较麻烦

image-20210808213629343

1.3 传统方式问题分析

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

2、中介者模式基本介绍

2.1 基本介绍

  1. 中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
  2. 比如MVC模式，C（Controller控制器）是M（Model模型）和V（View视图）的中介者，在前后端交互起到了中间人的作用

2.2 原理类图

image-20210808220407707

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

2.3 实例类图

image-20210808222503624

操作流程：

  1. 创建ConcreteMediator对象
  2. 创建各个同事类对象，比如：Alarm、CoffeeMachine、TV…
  3. 在创建同事类对象的时候，就直接通过构造器，加入到ColleagueMap
  4. 同事类对象，可以调用sendMessage，最终会去调用ConcreteMediator类的getMessage方法
  5. getMessage会根据接收到的同事对象发出的消息来协调调用其他的同事对象，完成任务
  6. 可以看到getMessage是核心方法，完成相应任务

3、代码实例

3.1 Mediator抽象类

1
2
3
4
5
6
7
8
9
public abstract class Mediator {
    //将给的中介者对象，加入到集合中
    public abstract void Register(String colleagueName,Colleague colleague);

    //接收消息，具体的同事对象发出
    public abstract void GetMessage(int stateChange,String colleague);

    public abstract void SendMessage();
}

3.2 Colleague 抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//同事抽象类
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 mediator;
    }

    public abstract void SendMessage(int stateChange);
}

3.3 Alarm类

继承Colleague

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//具体的同事类
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);
    }
}

3.4 CofeeMachine类

继承Colleague

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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(" 等待5分钟 ");
        System.out.println(" 咖啡制作完成 ");
        SendMessage(0);
    }
}

3.5 Curtains类

继承Colleague

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//窗帘
public class Curtains extends Colleague{
    public Curtains(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 UpCurtains(){
        System.out.println(" 准备拉上窗帘 ");
    }
}

3.6 TV类

继承Colleague

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//电视
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(" 打开TV ");
    }

    public void StopTv(){
        System.out.println(" 关闭TV ");
    }
}

3.7 ConcreteMediator类

继承Mediator类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.HashMap;

//具体的中介者类
public class ConcreteMediator extends Mediator {
    //集合，放入所有的同事对象
    private HashMap<String,Colleague> colleagueHashMap;
    private HashMap<String,String> interMap;

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

    //同事注册类，内部维护了HashMap
    @Override
    public void Register(String colleagueName, Colleague colleague) {
        colleagueHashMap.put(colleagueName,colleague);
        if (colleague instanceof  Alarm)// instanceof 左边是对象，右边是类，当左边对象是右边类创建时，返回true
            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
    public void GetMessage(int stateChange, String colleagueName) {
        if(colleagueHashMap.get(colleagueName) instanceof  Alarm){
            if(stateChange == 0){
                ((CoffeeMachine)(colleagueHashMap.get(interMap.get("CoffeeMachine")))).StartCoffee();
                ((TV)(colleagueHashMap.get(interMap.get("TV")))).StartTv();
            }else if(stateChange == 1){
                ((TV)(colleagueHashMap.get(interMap.get("TV")))).StopTv();
            }
        }else if(colleagueHashMap.get(colleagueName) instanceof  CoffeeMachine){
            ((Curtains)(colleagueHashMap.get(interMap.get("Curtains")))).UpCurtains();
        }else if(colleagueHashMap.get(colleagueName) instanceof  TV ){
            //如果TV发现消息
        }else if(colleagueHashMap.get(colleagueName) instanceof  Curtains){
            //如果是窗帘发出的消息，这里处理...
        }
    }

    @Override
    public void SendMessage() {
    }
}

3.8 ClientTest类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ClientTest {
    public static void main(String[] args) {
        //创建一个中介者对象
        Mediator mediator = new ConcreteMediator();

        //创建Alarm 并且加入到ConcreteMediator 对象的HashMap
        Alarm alarm = new Alarm(mediator, "Alarm");

        //创建CoffeeMachine对象，并且加入到ConcreteMediator对象的HashMap
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "CoffeeMachine");

        //创建Curtains, 并且加入到 ConcreteMediator 对象的HashMap
        Curtains curtains = new Curtains(mediator, "Curtains");
        TV tv = new TV(mediator, "TV");

        //让闹钟发出消息（在中介者中对消息进行处理，getMessage）
        alarm.SendAlarm(0);
        coffeeMachine.FinishCoffee();
        alarm.SendAlarm(1);
    }
}

结果：

1
2
3
4
5
6
开始制作咖啡 
打开TV 
等待5分钟 
咖啡制作完成 
准备拉上窗帘 
关闭TV

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

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