中介者模式是一种行为设计模式，它通过引入一个中介对象来封装一组对象之间的交互。这种模式实现了对象间的解耦，使得对象之间的依赖关系变得更为松散，从而提高了系统的灵活性和可扩展性。中介者模式也简化了对象间的通信，使得对象之间的交互变得更加清晰和易于理解。
在软件开发中，随着项目规模的不断扩大，对象之间的交互变得越来越复杂，为了降低对象之间的耦合度，提高代码的可维护性和可扩展性，我们需要采用一些设计模式来优化代码结构，中介者模式（Mediator Pattern）就是一种非常实用的设计模式，它通过引入一个中介者对象来封装对象之间的交互，从而实现对象间的解耦与通信。
中介者模式的定义：
中介者模式是一种行为型设计模式，它定义了一个对象（中介者）来封装一组对象之间的交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
中介者模式的主要角色：
1、抽象中介者（Mediator）：定义统一的接口，用于各对象之间的通信。
2、具体中介者（ConcreteMediator）：实现抽象中介者定义的接口，处理对象之间的交互。
3、抽象同事类（Colleague）：定义统一的接口，用于与其他对象进行交互。
4、具体同事类（ConcreteColleague）：实现抽象同事类定义的接口，与其他对象进行交互。
中介者模式的应用场景：
1、多个对象之间需要进行复杂的交互，且这些交互会导致对象之间的耦合度增加。
2、需要降低多个对象之间的依赖关系，提高代码的可维护性和可扩展性。
3、一个对象的状态发生改变时，需要通知其他对象，以便它们做出相应的响应。
中介者模式的实现步骤：
1、定义抽象中介者（Mediator）和抽象同事类（Colleague），以及它们之间的交互接口。
2、创建具体中介者（ConcreteMediator）对象，实现抽象中介者定义的接口。
3、创建具体同事类（ConcreteColleague）对象，实现抽象同事类定义的接口。
4、将具体同事类对象注册到具体中介者对象中。
5、当某个具体同事类对象需要与其他对象进行交互时，通过具体中介者对象进行通信。
下面通过一个简单的例子来说明中介者模式的实现过程。
假设我们有一个聊天室应用程序，其中有多个用户（User）和多个群组（Group），用户可以通过群组发送和接收消息，为了实现用户之间的解耦和通信，我们可以使用中介者模式。
我们定义抽象中介者（Mediator）和抽象同事类（Colleague）：
// Mediator.java
public interface Mediator {
void sendMessage(String message, Colleague sender, Colleague receiver);
}
// Colleague.java
public interface Colleague {
void receiveMessage(String message);
}我们创建具体中介者（ConcreteMediator）对象，实现抽象中介者定义的接口：
// ConcreteMediator.java
public class ConcreteMediator implements Mediator {
private List<Colleague> users = new ArrayList<>();
private List<Colleague> groups = new ArrayList<>();
@Override
public void sendMessage(String message, Colleague sender, Colleague receiver) {
if (sender instanceof User && receiver instanceof Group) {
users.remove(receiver);
groups.add((Group) receiver);
} else if (sender instanceof Group && receiver instanceof User) {
groups.remove(sender);
users.add((User) receiver);
} else {
throw new IllegalArgumentException("Invalid sender or receiver");
}
for (Colleague colleague : users) {
colleague.receiveMessage(message);
}
for (Colleague colleague : groups) {
colleague.receiveMessage(message);
}
}
}我们创建具体同事类（ConcreteColleague）对象，实现抽象同事类定义的接口：
// User.java
public class User implements Colleague {
private String name;
public User(String name) {
this.name = name;
}
@Override
public void receiveMessage(String message) {
System.out.println(name + " received message: " + message);
}
}
// Group.java
public class Group implements Colleague {
private String groupName;
public Group(String groupName) {
this.groupName = groupName;
}
@Override
public void receiveMessage(String message) {
System.out.println("Group " + groupName + " received message: " + message);
}
}我们将具体同事类对象注册到具体中介者对象中，并实现消息的发送和接收：
public class Main {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
User user1 = new User("Alice");
User user2 = new User("Bob");
Group group1 = new Group("Admin");
Group group2 = new Group("Users");
mediator.sendMessage("Hello, everyone!", user1, null); // 发送给所有用户
mediator.sendMessage("Hello, everyone!", group1, null); // 发送给所有群组
mediator.sendMessage("Hello, Bob!", user2, null); // 发送给Bob
mediator.sendMessage("Hello, Alice!", user1, null); // 发送给Alice
mediator.sendMessage("Hello, Users!", group2, null); // 发送给Users群组
}
}通过以上示例，我们可以看到中介者模式实现了对象间的解耦和通信，当一个对象的状态发生改变时，只需要通过中介者对象进行通信，而不需要直接与其他对象进行交互，从而降低了对象之间的耦合度，提高了代码的可维护性和可扩展性。
