定义
中介者模式（Mediator Pattern）是一种行为型设计模式，它用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
以下是中介者模式的主要特点和定义：
主要角色
-
Mediator（抽象中介者） ：
- 定义了同事对象到中介者对象的接口。
-
ConcreteMediator（具体中介者） ：
- 实现抽象中介者的方法，协调各个同事对象之间的交互。
- 它知道所有的具体同事类，并从具体同事接收消息，向具体同事对象发出命令。
-
Colleague（抽象同事类） ：
- 定义了同事对象的接口，其中包含了与中介者通信的方法。
-
ConcreteColleague（具体同事类） ：
- 实现抽象同事类，每个具体同事类只知道自己的行为，而不了解其他同事类的情况，但它们都认识中介者对象。
业务
假设我们有一个聊天系统，用户之间的消息通过一个聊天服务器（中介者）进行传递。
classDiagram
class User {
-ChatMediator mediator
-String name
+User(ChatMediator, String)
+send(String) : void
+receive(String) : void
}
class ChatUser {
+ChatUser(ChatMediator, String)
+send(String) : void
+receive(String) : void
}
class ChatMediator {
+sendMessage(String, User) : void
}
class ChatServer {
-List<User> users
+ChatServer()
+addUser(User) : void
+sendMessage(String, User) : void
}
ChatUser --> User
ChatServer --> ChatMediator
ChatServer --> User
一、定义抽象同事类（Colleague）
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);
}
二、定义具体同事类（ConcreteColleague）
class ChatUser extends User {
public ChatUser(ChatMediator mediator, String name) {
super(mediator, name);
}
@Override
public void send(String message) {
mediator.sendMessage(message, this);
}
@Override
public void receive(String message) {
System.out.println(name + " received: " + message);
}
}
三、定义抽象中介者（Mediator）
interface ChatMediator {
void sendMessage(String message, User user);
}
四、定义具体中介者（ConcreteMediator）
class ChatServer implements ChatMediator {
private List<User> users;
public ChatServer() {
users = new ArrayList<>();
}
public void addUser(User user) {
users.add(user);
}
@Override
public void sendMessage(String message, User sender) {
for (User user : users) {
if (user!= sender) {
user.receive(message);
}
}
}
}
五、使用中介者模式
public class MediatorPatternExample {
public static void main(String[] args) {
ChatServer server = new ChatServer();
User user1 = new ChatUser(server, "User 1");
User user2 = new ChatUser(server, "User 2");
User user3 = new ChatUser(server, "User 3");
server.addUser(user1);
server.addUser(user2);
server.addUser(user3);
user1.send("Hello everyone!");
user2.send("Hi there!");
}
}
在这个例子中，User是抽象同事类，ChatUser是具体同事类，它们通过ChatMediator接口与中介者进行通信。ChatServer是具体中介者，负责协调用户之间的消息传递。通过这种方式，用户之间不需要直接相互引用，而是通过聊天服务器进行通信，降低了系统的耦合度。
总结
使用场景
-
一组对象以复杂的方式进行通信，导致依赖关系混乱且难以维护。
- 例如在一个聊天应用中，多个用户之间的消息传递可以通过一个中介者来管理，避免用户之间直接相互引用。
-
想要封装和简化复杂的交互逻辑。
- 当一个系统中的对象之间的交互非常复杂时，可以使用中介者模式将这些交互集中在一个中介者对象中，使得系统更容易理解和维护。
优点
-
减少了对象之间的耦合度。
- 各个对象之间不再直接相互引用，而是通过中介者进行通信，降低了系统的复杂性。
-
集中控制交互逻辑。
- 可以将复杂的交互逻辑集中在中介者对象中，使得系统的维护和扩展更加容易。
缺点
-
中介者可能会变得过于复杂。
- 如果系统中的交互非常复杂，中介者对象可能会变得非常庞大和复杂，难以维护。
-
可能会产生性能问题。
- 由于所有的交互都通过中介者进行，可能会导致性能下降，特别是在高并发的情况下。
