博主介绍： ✌博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家✌
Java知识图谱点击链接：体系化学习Java（Java面试专题）
💕💕 感兴趣的同学可以收藏关注下 ，不然下次找不到哟💕💕
文章目录
- 1、什么是中介者模式
- 2、中介者模式的优缺点
- 3、中介者模式的应用场景
- 4、中介者模式的结构
- 5、中介者模式的原理
- 6、中介者模式的代码案例
1、什么是中介者模式
中介者模式是一种行为型设计模式，用于降低多个对象之间的耦合性。在中介者模式中，多个对象之间不直接相互通信，而是通过一个中介者对象进行通信。中介者对象封装了对象之间的交互逻辑，使得对象之间的通信变得简单而灵活。
中介者模式的核心思想是将对象之间的交互逻辑集中管理，避免了对象之间的直接依赖关系，从而提高了系统的可维护性和扩展性。通过引入中介者对象，可以将系统中复杂的交互关系变为多个简单的一对多关系，使得系统更易于理解和维护。
2、中介者模式的优缺点
中介者模式的优点包括：
- 降低了对象之间的耦合性：中介者模式将对象之间的交互逻辑集中在中介者对象中，使得对象之间不直接相互通信，从而降低了对象之间的耦合性。
- 简化了对象之间的交互：通过引入中介者对象，可以将复杂的交互关系变为多个简单的一对多关系，使得对象之间的通信变得简单而灵活。
- 提高了系统的可维护性和扩展性：由于对象之间的交互逻辑集中在中介者对象中，当系统需要修改交互逻辑时，只需修改中介者对象而不影响其他对象，提高了系统的可维护性和扩展性。
- 促进了代码复用：中介者模式将对象之间的通信逻辑集中在中介者对象中，使得这些逻辑可以被多个对象共享和复用。
中介者模式的缺点包括：
- 中介者对象可能会变得复杂：随着系统中对象之间的交互关系增多，中介者对象可能会变得复杂，包含大量的逻辑和方法。
- 中介者模式可能导致单点故障：由于多个对象之间的通信都依赖于中介者对象，如果中介者对象出现问题，可能会导致整个系统的功能受影响。
- 中介者模式可能降低系统的性能：由于中介者对象需要处理多个对象之间的通信，可能会导致系统的性能下降。
因此，在使用中介者模式时，需要权衡其优点和缺点，根据具体的场景来选择是否使用该模式。
3、中介者模式的应用场景
中介者模式适用于以下场景：
- 多个对象之间存在复杂的交互关系：当系统中多个对象之间存在复杂的交互关系，并且彼此之间的通信逻辑较为复杂时，可以使用中介者模式将这些交互逻辑集中在中介者对象中，简化对象之间的通信。
- 系统中对象之间的耦合性较高：当系统中的对象之间的耦合性较高，彼此之间的依赖关系较为复杂时，可以使用中介者模式将对象之间的交互逻辑解耦，通过引入中介者对象来降低对象之间的耦合性。
- 系统中的对象需要进行集中管理：当系统中的对象需要进行集中管理，例如需要对对象之间的通信进行调度、协调或控制时，可以使用中介者模式来管理这些对象。
- 系统中的对象之间的交互频繁且复杂：当系统中的对象之间的交互频繁且交互逻辑较为复杂时，可以使用中介者模式将这些复杂的交互逻辑集中在中介者对象中，提高系统的可维护性和扩展性。
- 系统中的对象之间存在循环依赖：当系统中的对象之间存在循环依赖关系，导致彼此之间难以直接通信时，可以使用中介者模式将这些循环依赖关系转化为一对多的关系，通过中介者对象来解决通信问题。
总之，中介者模式适用于对象之间存在复杂的交互关系、耦合性较高、需要集中管理、交互频繁且复杂、存在循环依赖等场景。通过引入中介者对象，可以简化对象之间的通信，提高系统的可维护性和扩展性。
4、中介者模式的结构
中介者模式的结构包括以下几个角色：
- 抽象中介者（Abstract Mediator）：定义了中介者的接口，声明了各个同事对象之间通信的方法。
- 具体中介者（Concrete Mediator）：实现了抽象中介者接口，协调各个具体同事对象之间的交互关系。
- 抽象同事类（Abstract Colleague）：定义了同事类的接口，维护一个抽象中介者的引用，用于与其他同事对象进行通信。
- 具体同事类（Concrete Colleague）：实现了抽象同事类的接口，具体同事对象之间通过中介者进行通信。
中介者模式的结构图如下：
| Abstract Mediator |
+---------------------+
| + doSomething() |
| + colleagueChanged()|
+---------------------+
/_\
|
|
+------------------+
| Concrete |
| Mediator |
+------------------+
| + doSomething() |
| + colleague1 |
| + colleague2 |
+------------------+
/_\
|
|
+-------------------------+
| Abstract Colleague |
+-------------------------+
| + mediator |
| + send(message) |
| + receive(message) |
+-------------------------+
/_\
|
|
+-------------------------+
| Concrete Colleague 1 |
+-------------------------+
| + send(message) |
| + receive(message) |
+-------------------------+
/_\
|
|
+-------------------------+
| Concrete Colleague 2 |
+-------------------------+
| + send(message) |
| + receive(message) |
+-------------------------+在中介者模式中，抽象中介者定义了中介者的接口，具体中介者实现了该接口，并负责协调各个具体同事对象之间的交互关系。抽象同事类定义了同事类的接口，具体同事类实现了该接口，并通过中介者进行通信。通过中介者对象，各个同事对象之间的交互被集中在中介者对象中，从而降低了对象之间的耦合性。
5、中介者模式的原理
中介者模式的原理是通过引入一个中介者对象，将多个对象之间的交互行为集中管理和调度。在中介者模式中，各个对象之间不直接相互通信，而是通过中介者来进行通信和协调。
当各个对象之间需要进行复杂的通信和交互时，如果直接让它们相互引用，会导致对象之间的耦合度很高，难以维护和扩展。而中介者模式通过引入中介者对象，将对象之间的交互行为解耦，使得对象之间的通信通过中介者进行，从而简化了对象之间的关系。
中介者模式的核心思想是将对象之间的通信集中管理，通过中介者对象来协调各个对象之间的交互。当一个对象需要与其他对象进行通信时，它不需要直接与其他对象交互，而是通过中介者来发送和接收消息。中介者负责将消息传递给目标对象，并处理各个对象之间的交互逻辑。
通过中介者模式，可以实现一对多的关系，即一个中介者对象可以管理多个对象之间的交互。当一个对象发生变化时，只需要通知中介者对象，中介者对象会负责将变化传递给其他相关的对象。这样，对象之间的关系变得灵活可扩展，各个对象之间的耦合度也降低了。
总结来说，中介者模式通过引入中介者对象，将对象之间的通信和交互行为集中管理，解耦了对象之间的关系，提高了系统的灵活性和可扩展性。
6、中介者模式的代码案例
以下是一个简单的中介者模式的代码案例：
package com.pany.camp.design.principle.mediator;
/**
*
* @description: 接口类
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 15:59
*/
public interface Mediator {
void sendMessage(String message, Colleague colleague);
}package com.pany.camp.design.principle.mediator;
/**
*
* @description: 具体中介者类
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 16:00
*/
class ConcreteMediator implements Mediator {
private Colleague colleague1;
private Colleague colleague2;
public void setColleague1(Colleague colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague colleague2) {
this.colleague2 = colleague2;
}
@Override
public void sendMessage(String message, Colleague colleague) {
if (colleague == colleague1) {
colleague2.receiveMessage(message);
} else if (colleague == colleague2) {
colleague1.receiveMessage(message);
}
}
}package com.pany.camp.design.principle.mediator;
/**
*
* @description: 抽象同事类
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 16:00
*/
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void sendMessage(String message);
public abstract void receiveMessage(String message);
}package com.pany.camp.design.principle.mediator;
/**
*
* @description: 具体同事类
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 16:01
*/
public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
@Override
public void sendMessage(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receiveMessage(String message) {
System.out.println("ConcreteColleague1 received message: " + message);
}
}package com.pany.camp.design.principle.mediator;
/**
* @description: 具体同事类
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 16:01
*/
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void sendMessage(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receiveMessage(String message) {
System.out.println("ConcreteColleague2 received message: " + message);
}
}package com.pany.camp.design.principle.mediator;
/**
*
* @description: 客户端
* @copyright: @Copyright (c) 2022
* @company: Aiocloud
* @author: pany
* @version: 1.0.0
* @createTime: 2023-06-28 16:01
*/
public class Client {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
mediator.setColleague1(colleague1);
mediator.setColleague2(colleague2);
colleague1.sendMessage("Hello from colleague1");
colleague2.sendMessage("Hi from colleague2");
}
}我们定义了一个中介者接口Mediator和具体中介者类ConcreteMediator。抽象同事类Colleague定义了同事类的基本行为，具体同事类ConcreteColleague1和ConcreteColleague2继承自Colleague并实现了具体的行为。在测试代码中，我们创建了中介者对象和两个具体同事对象，并将它们注册到中介者中。然后，通过调用同事对象的sendMessage方法发送消息，中介者会根据发送消息的同事对象将消息传递给其他同事对象。最后，每个具体同事对象接收到消息后会进行相应的处理。
这个简单的示例展示了中介者模式的基本原理和用法。实际应用中，中介者模式可以用于更复杂的对象之间的通信和协调。
输出结果如下：
ConcreteColleague2 received message: Hello from colleague1
ConcreteColleague1 received message: Hi from colleague2
Process finished with exit code 0
