智能家庭管理问题

1. 智能家庭包括各种设备：闹钟、咖啡机、电视机、窗帘等
2. 要看电视时，各个设备可以协同工作，自动完成看电视的准备工作**（准备工作又一定的流程）**，比如流程：闹铃响起——咖啡机做咖啡——窗帘落下——电视机播放

传统方案

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

中介者模式

基本介绍

1. 中介者模式，用一个中介对象来封装一系列的对象交互，中介者使各个对象之间不需要显式的相互引用，从而使其松耦合，可以独立地改变他们之间的交互
2. 中介者模式属于行为型模式，使代码松耦合，提高扩展性和维护性
3. 比如MVC模式，C就是M和V的中介者，C负责所有调用的控制，在前后端之间起到了中间人的作用

原理

1. Mediator：抽象中介者，定义了同时对象到中介者对象的接口
2. Colleague：抽象同事类
3. ConcreteMediator：具体的中介者，实现抽象方法，需要知道所有的具体的同事类，并接受同事类的消息，完成相应的任务
4. ConcreteColleague：具体的同事类，每个同事类只知道自己的行为，不了解其他同时的行为，但是他们都依赖中介者对象，需要调用其他同事类时，都交给中介者去做

中介者模式解决只能家庭管理

/***
 * @author shaofan
 * @Description 中介者模式解决智能家居问题
 */
public class Family {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Alarm alarm = new Alarm(mediator,"alarm");
        TV TV = new TV(mediator,"TV");
        alarm.sendAlarm(0);
    }
}

abstract class Mediator{

    public abstract void register(String name,Colleague colleague);
    public abstract void getMessage(int stateChange,String name);
    public abstract void sendMessage();
}

class ConcreteMediator extends Mediator{
    HashMap<String,Colleague> colleagues;
    HashMap<String,String> interMap;
    public ConcreteMediator(){
        colleagues = new HashMap<>();
        interMap = new HashMap<>();
    }

    @Override
    public void register(String name, Colleague colleague) {
        colleagues.put(name,colleague);
        if(colleague instanceof Alarm){
            interMap.put("alarm",name);
        }else if(colleague instanceof TV){
            interMap.put("TV",name);
        }
    }

    @Override
    public void getMessage(int stateChange, String name) {
        if(colleagues.get(name) instanceof Alarm){
            if(stateChange==0){
                ((TV) colleagues.get(interMap.get("TV"))).start();
            }else if(stateChange==1){
                ((TV) colleagues.get(interMap.get("TV"))).stop();
            }
        }else if(colleagues.get(name) instanceof TV){
            // 对于TV的消息处理
        }
    }

    @Override
    public void sendMessage() {

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

class Alarm extends Colleague{

    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        //在实例化时，将自己注册到中介者中，让中介者管理
        this.getMediator().register(name,this);
    }

    public void sendAlarm(int stateChange){
        sendMessage(stateChange);
    }

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

class TV extends Colleague{

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

    public void start(){
        System.out.println("TV work");
    }
    public void stop(){
        System.out.println("TV stop");
    }

    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,name);
    }
}
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

总结

1. 多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，松耦合
2. 减少类间依赖，降低了耦合，符合迪米特法则
3. 中介者承担了较多的责任，一旦中介者出现了问题，整个系统都会受影响
4. 如果设计不当，中介者本身会变得过于复杂