当前位置：首页 > ops >正文

设计模式之中介者模式

ops 2025/8/29 14:35:52

在我们实际开发中，我们经常会遇到多个对象之间互相依赖、互相调用的场景。如果这些对象之间的耦合度太高，不仅会让系统变得难以维护，还会让扩展变得异常困难。此时，中介者模式(Mediatro)就是一种非常实用的设计方案，它可以有效地降低对象之间的耦合度，让系统更加灵活、可维护。

1. 概念

中介者模式是一种行为型设计模式，它的核心思想是：通过引入一个中介对象，将多个对象之间的交互封装在中介者中，避免对象之间直接引用，从而使它们解藕。

通俗地说，中介者就像一个“调度员”，各个同事之间不直接沟通，而是通过中介者来协作。

主要包含以下几个角色：

1. Mediator(抽象中介者)：定义同事对象之间通信的接口；

2. ConcreteMediator(具体中介者)：实现协调逻辑，知道所有的同事对象；

3. Colleague(抽象同事类)：定义中介者对象的引用；

4. ConcreteColleague(具体同事类)：通过中介者与其他同事通信。

2. 代码实现

这里我们使用一个聊天室的例子来演示中介者模式：

首先我们定义一个抽象中介者接口（抽象层就可以当作一个规范即可，不用过多关注）：

public interface ChatMediator {void sendMessage(String message, User user);void addUser(User user);
}

其次我们来创建一个具体的实现类：

import java.util.ArrayList;
import java.util.List;public class ChatRoom implements ChatMediator {private List<User> users = new ArrayList<>();@Overridepublic void sendMessage(String message, User sender) {for (User user : users) {// 不给自己发消息if (user != sender) {user.receive(message);}}}@Overridepublic void addUser(User user) {users.add(user);}
}

接下来我们来编写抽象同事类（同样作为一个抽象层可以不用过多关注）：

public abstract class User {protected ChatMediator mediator;protected String name;public User(ChatMediator mediator, String name) {this.mediator = mediator;this.name = name;}public abstract void send(String message);public abstract void receive(String message);
}

接下来编写同事类的实现：

public class ChatUser extends User {public ChatUser(ChatMediator mediator, String name) {super(mediator, name);}@Overridepublic void send(String message) {System.out.println(this.name + " 发送消息: " + message);mediator.sendMessage(message, this);}@Overridepublic void receive(String message) {System.out.println(this.name + " 收到消息: " + message);}
}

外部测试类：

public class MediatorPatternDemo {public static void main(String[] args) {ChatMediator chatRoom = new ChatRoom();User user1 = new ChatUser(chatRoom, "Alice");User user2 = new ChatUser(chatRoom, "Bob");User user3 = new ChatUser(chatRoom, "Charlie");chatRoom.addUser(user1);chatRoom.addUser(user2);chatRoom.addUser(user3);user1.send("大家好！");user2.send("Hi Alice！");}
}// 输出结果：
// Alice 发送消息: 大家好！
// Bob 收到消息: 大家好！
// Charlie 收到消息: 大家好！
// Bob 发送消息: Hi Alice！
// Alice 收到消息: Hi Alice！
// Charlie 收到消息: Hi Alice！

其实一些初级开发者会觉得，这样做并没有什么意义，只是加了一层中间层，那么我给大家编写一下不使用中介者模式的代码实现：

import java.util.List;public class User {private String name;private List<User> contacts;public User(String name) {this.name = name;}public void setContacts(List<User> contacts) {this.contacts = contacts;}public void sendMessage(String message) {System.out.println(this.name + " 发送消息: " + message);for (User user : contacts) {// 不给自己发消息if (!user.equals(this)) {user.receiveMessage(message);}}}public void receiveMessage(String message) {System.out.println(this.name + " 收到消息: " + message);}public String getName() {return name;}
}

这里存在的问题就是每个User对象都需要手动维护联系人列表，同时User类不仅负责发送和接收，还要管理用户间的通信逻辑，严重违反了单一职责原则！这样我们的代码耦合度过高，无法灵活扩展、测试也变得困难。