【设计模式】Java设计模式 - 中介者模式

Java设计模式 - 中介者模式

😄生命不息，写作不止
🔥 继续踏上学习之路，学之分享笔记
👊 总有一天我也能像各位大佬一样
🏆 一个有梦有戏的人 @怒放吧德德
🌝分享学习心得，欢迎指正，大家一起学习成长！

养成自主学习的好习惯，希望读者也一起学习，一起进步！
不断尝试，不断改进，只为更好的输出。

简介

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

中介者模式原理分析

用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者封装了具体的方法，可以让调用者看不到内部的复杂关系。
简单原理UML图：

角色与职责

• Colleague：抽象同事类
• ConcreteColleague：具体同事类，有许多的类，只是知道自己的行为，不会干涉其他类的行为，依赖中介者对象
• Mediator：抽象中介者，定义了同事对象到中介者对象的接口
• ConcreteMediator：具体中介者对象，通过集合管理所有的具体同事类

中介者模式实例

本次实验采用家庭儿子找爸爸拿钱，爸爸需要妈妈同意的案例来讲解中介者模式。中国家庭男人不是怕老婆，而是对老婆的一种尊重！哈哈哈，进入正题，中介者模式说得通俗点就是定义共同父类-同事类，在这个抽象同事类中聚合中介者接口类，而中介者需要实现注册方法，用来存放同事类子类。具体的类去继承抽象同事类，在里面中实现自己方法，并且不直接调用其他同事类的方法，统一又一个接口去实现。具体的中介者类除了初始化数据，需要根据得到消息，完成对应任务，协调各个具体的同事对象，完成任务。
具体代码如下解析，先看一下整体类图：

①、定义抽象同事类

定义一个同事类，需要聚合中介者接口类，并通过构造方法来初始化。

package com.lyd.demo.home.colleague;
import com.lyd.demo.home.mediator.Mediator;
/**
 * @Author: lyd
 * @Description: 同事抽象类
 * @Date: 2022-09-14
 */
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); // 抽象方法。。。发送信息
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

②、具体同事类

在构造方法中，将此类注册到中介者集合中，并且提供一些具体方法，通过sendMessage让中介者来处理。
其中三种子类都相似。

// 儿子
package com.lyd.demo.home.colleague.character;
import com.lyd.demo.home.colleague.Colleague;
import com.lyd.demo.home.mediator.Mediator;
/**
 * @Author: lyd
 * @Description: 具体类
 * @Date: 2022-09-14
 */
public class Son extends Colleague {
    public Son(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name, this);
    }
    public void getMoney() {
        System.out.println("儿子: 爸爸拿钱");
        this.sendMessage(0);
    }
    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange, this.name);
    }
}
// 父亲
package com.lyd.demo.home.colleague.character;
import com.lyd.demo.home.colleague.Colleague;
import com.lyd.demo.home.mediator.Mediator;
/**
 * @Author: lyd
 * @Description: 具体类
 * @Date: 2022-09-14
 */
public class Father extends Colleague {
    /**
     * 注册实例
     * @param mediator
     * @param name
     */
    public Father(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name, this);
    }
    public void getMoney() {
        System.out.println("爸爸: 需要妈妈同意");
        this.sendMessage(0);
    }
    public void giveMoney(int yes) {
        if (yes == 1)
            System.out.println("爸爸: 妈妈同意给钱，给你钱");
        else
            System.out.println("爸爸: 对不起，妈妈不同意给钱");
    }
    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange, this.name);
    }
}
// 母亲
package com.lyd.demo.home.colleague.character;
import com.lyd.demo.home.colleague.Colleague;
import com.lyd.demo.home.mediator.Mediator;
/**
 * @Author: lyd
 * @Description: 具体类
 * @Date: 2022-09-14
 */
public class Mather extends Colleague {
    public Mather(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name, this);
    }
    public void sayNo() {
        System.out.println("妈妈: 小孩子要钱干嘛？不同意！");
        this.sendMessage(0);
    }
    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange, this.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

③、中介者接口类

定义接口，给具体实现类实现。

package com.lyd.demo.home.mediator;
import com.lyd.demo.home.colleague.Colleague;
/**
 * @Author: lyd
 * @Description: 中介者接口类
 * @Date: 2022-09-14
 */
public interface Mediator {
    /**
     * 将对象加入到中介者集合中
     * @param colleagueName
     * @param colleague
     */
    public void register(String colleagueName, Colleague colleague);
    /**
     * 接收具体的同事发出的消息
     * @param stateChange
     * @param colleagueName
     */
    public void getMessage(int stateChange, String colleagueName);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

④、中介者实现类

定义集合来存放同事类，通过构造器来初始化，register：将同事类存入集合中，并将该同事类的名称也一同记录下来完成数据保存。getMessage：核心方法，通过对比对象类型来得知哪个对象发来的消息，并且根据逻辑协调各个具体的同事对象，完成任务。

package com.lyd.demo.home.mediator.impl;
import com.lyd.demo.home.colleague.Colleague;
import com.lyd.demo.home.colleague.character.Father;
import com.lyd.demo.home.colleague.character.Mather;
import com.lyd.demo.home.colleague.character.Son;
import com.lyd.demo.home.mediator.Mediator;
import java.util.HashMap;
/**
 * @Author: lyd
 * @Description: 中介者实现类 - 具体中介者
 * @Date: 2022-09-14
 */
public class MediatorImpl implements Mediator {
    // 集合，放入所有的同事类
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;
    // 构造方法初始化数据
    public MediatorImpl() {
        this.colleagueMap = new HashMap<String, Colleague>();
        this.interMap = new HashMap<String, String>();
    }
    @Override
    public void register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName, colleague);
        if (colleague instanceof Son) {
            interMap.put("Son", colleagueName);
        } else if (colleague instanceof Father) {
            interMap.put("Father", colleagueName);
        } else {
            interMap.put("Mather", colleagueName);
        }
    }
    /**
     * 具体中介者的核心方法
     * 1. 根据得到消息，完成对应任务
     * 2. 中介者在这个方法，协调各个具体的同事对象，完成任务
     * @param stateChange
     * @param colleagueName
     */
    @Override
    public void getMessage(int stateChange, String colleagueName) {
        if (colleagueMap.get(colleagueName) instanceof Son) { // 儿子发起找爸爸要钱
            ((Father)(colleagueMap.get(interMap.get("Father")))).getMoney();
        } else if (colleagueMap.get(colleagueName) instanceof Father) { // 爸爸说找妈妈拿
            ((Mather)(colleagueMap.get(interMap.get("Mather")))).sayNo();
        } else { // 妈妈说不，爸爸就不能给钱
            ((Father)(colleagueMap.get(interMap.get("Father")))).giveMoney(stateChange);
        }
    }
}
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

⑤、测试类

创建中介者，创建具体同事类，并注册到中介者集合中。通过调用儿子类的getMoney方法。

package com.lyd.demo.home.test;
import com.lyd.demo.home.colleague.character.Father;
import com.lyd.demo.home.colleague.character.Mather;
import com.lyd.demo.home.colleague.character.Son;
import com.lyd.demo.home.mediator.Mediator;
import com.lyd.demo.home.mediator.impl.MediatorImpl;
/**
 * @Author: lyd
 * @Description:
 * @Date: 2022-09-14
 */
public class Test {
    public static void main(String[] args) {
        Mediator mediator = new MediatorImpl();
        Son son = new Son(mediator, "son");
        Father father = new Father(mediator, "father");
        Mather mather = new Mather(mediator, "mather");
        son.getMoney();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果

23种设计模式也都介绍完了，下一次准备将这些做个整合，方便查找观看！

👍创作不易，可能有些语言不是很通畅，如有错误请指正，感谢观看！记得一键三连哦！👍

💓德德小建议：

理解设计模式不是一件简单的事情，需要不断的学习和动手去练习，才能理解。只有掌握好设计模式，才能够真正的理解SpringAOP和Mybatis的底层原理。各位读者可以和我一样，动手敲一敲代码，甚至用不同的例子来做，通过debug一步一步调试，还有就是多看看别人的例子。能够有助于理解！谢谢各位观看指点！❤️ ❤️ ❤️