【设计模式深度剖析】【6】【行为型】【中介者模式】

👈️上一篇:迭代器模式 | 下一篇:观察者模式👉️

设计模式-专栏👈️

文章目录

中介者模式
定义
- 英文原文
- 直译
- 如何理解？
中介者模式的角色
- 1. 中介者（Mediator）
- 2. 具体中介者（ConcreteMediator）
- 3. 同事（Colleague）
- 类图
- 代码示例
中介者模式的应用
- 优点
- 缺点
- 使用场景

中介者模式

中介者模式（Mediator）也称调停者模式

复杂的网状结构——>星型结构：通过中介者来调停每个类只与中介者有联系，通过中介者解耦。

中介者模式就像是一位“交通警察”，在繁忙的十字路口指挥车辆和行人有序通过，避免他们之间的直接冲突和混乱。

定义

英文原文

Defines a separate (mediator) object that encapsulates the interaction between a set of objects and the objects delegate their interaction to a mediator object instead of interacting with each other directly.

直译

中介者模式定义了一个单独的（中介）对象，用于封装一组对象之间的交互。这组对象将它们的交互委托给中介对象，而不是直接相互交互。

如何理解？

松散耦合：中介者模式通过中介者对象封装了对象之间的交互，使得对象之间不需要直接引用，实现了松散耦合。
独立变化：由于交互逻辑被封装在中介者对象中，因此可以独立地改变对象之间的交互，而不需要修改大量的代码。

假设你正在组织一个家庭聚会，有很多亲戚朋友参与。如果你让每个参与者都直接与每个人交流（例如，每个人都要告诉其他人他们的饮食偏好），那么场面可能会非常混乱，而且很难确保每个人都得到了正确的信息。这时，你可以充当一个“中介者”的角色，让每个人只与你交流他们的需求，然后你再将这些需求传达给其他人。这样，整个聚会过程就会变得更加有序和高效。这就是中介者模式在现实生活中的一个简单应用。

中介者模式的角色

1. 中介者（Mediator）

定义了一个接口，用于封装多个同事（Colleague）对象之间的交互行为，协调它们之间的通信。

维护同事对象之间的关联关系。
协调多个同事对象之间的交互。
封装了同事对象之间的通信细节。

2. 具体中介者（ConcreteMediator）

实现了中介者接口，定义了具体的协调同事对象交互的逻辑。

了解并维护它的各个同事：提供注册同事对象的方法，持有同事对象的引用列表。
实现协调同事对象交互的逻辑。

3. 同事（Colleague）

持有中介者的引用，通过中介者与其他同事对象通信。

每一个同事类都知道它的中介者对象：持有中介者的引用。
提供注册到中介者的方法。
接收来自中介者的消息。
每一个同事对象在需要与其他同事通信的时候，与它的中介者通信：发送消息给中介者，再由中介者转发给其他同事。

类图

在这里插入图片描述

代码示例

package com.polaris.designpattern.list3.behavioral.pattern06.mediator.classicdemo;import java.util.ArrayList;
import java.util.List;//中介者接口
interface Mediator {void register(Colleague colleague);void relay(Colleague source, String message);
}//具体中介者实现
class ConcreteMediator implements Mediator {private List<Colleague> colleagues = new ArrayList<>();@Overridepublic void register(Colleague colleague) {colleagues.add(colleague);}@Overridepublic void relay(Colleague source, String message) {for (Colleague otherColleague : colleagues) {if (!otherColleague.equals(source)) {otherColleague.receive(message);}}}
}//同事接口
interface Colleague {void registerWith(Mediator mediator);void receive(String message);void send(String message);
}//具体同事实现
class ColleagueA implements Colleague {private Mediator mediator;public ColleagueA(Mediator mediator) {this.mediator = mediator;this.mediator.register(this); // 注册到中介者  }@Overridepublic void registerWith(Mediator mediator) {// 已在构造函数中注册，这里无需实现  }@Overridepublic void receive(String message) {System.out.println("ColleagueA received: " + message);}@Overridepublic void send(String message) {mediator.relay(this, message); // 委托给中介者发送消息  }
}// 同事B的实现与A类似
class ColleagueB implements Colleague {private Mediator mediator;public ColleagueB(Mediator mediator) {this.mediator = mediator;this.mediator.register(this); // 注册到中介者  }@Overridepublic void registerWith(Mediator mediator) {// 已在构造函数中注册，这里无需实现  }@Overridepublic void receive(String message) {System.out.println("ColleagueB received: " + message);}@Overridepublic void send(String message) {mediator.relay(this, message); // 委托给中介者发送消息  }
}//客户端代码
public class Client {public static void main(String[] args) {// 创建中介者  Mediator mediator = new ConcreteMediator();// 创建并注册同事对象  Colleague colleagueA = new ColleagueA(mediator);Colleague colleagueB = new ColleagueB(mediator); // 假设ColleagueB是另一个同事实现  // 同事A发送消息  colleagueA.send("Hello, everyone from ColleagueA!");// 同事B也可以发送消息（如果需要）  colleagueB.send("Hello, everyone from ColleagueB!");}
}  /* Output:
ColleagueB received: Hello, everyone from ColleagueA!
ColleagueA received: Hello, everyone from ColleagueB!
*///~

在这个例子中，ConcreteMediator 是具体的中介者类，它负责维护同事对象的列表，并协调它们之间的通信。ColleagueA 和 ColleagueB 是具体的同事类，它们通过中介者来发送和接收消息。在客户端代码中，我们创建了中介者和两个同事对象，并将它们注册到中介者中。然后，我们让 ColleagueA 发送一条消息，这条消息将通过中介者转发给所有其他同事（在这个例子中是 ColleagueB）。

中介者模式的应用

中介者模式是一种行为型设计模式，它允许多个对象之间通过一个中介者对象进行通信和协作。这种设计模式通常用于处理多个对象之间的复杂交互关系，以简化系统结构并提高可维护性。

在现实生活中，我们可以将机场的塔台视为一个中介者模式的例子。塔台作为中介者，负责协调不同飞机（对象）之间的起飞和降落，飞机之间无需直接相互通信，而是通过塔台进行交流。

优点

降低系统复杂性：通过将对象间的交互逻辑集中到一个中介者对象中，降低了对象间的直接耦合度，从而简化了系统结构。例如，在聊天室场景中，如果有8个人需要相互通信，使用中介者模式后，每个人只需要与中介者（聊天室）进行交互，而不是与其他7个人分别交互，大大降低了交互的复杂性。
提高可扩展性：当系统需要添加新的交互行为时，只需要修改或扩展中介者对象，而无需修改其他对象，从而提高了系统的可扩展性。
促进松散耦合：由于对象之间不再直接相互依赖，而是通过中介者进行交互，因此对象之间的耦合度大大降低，使得系统更加易于理解和维护。