目录
一、基础概念
二、UML类图
三、角色设计
四、案例分析
五、总结
一、基础概念
中介者模式的核心思想是引入一个中介者对象，来封装和管理对象之间的交互关系。
对象之间不再直接交互，而是通过中介者间接交互。这样可以减少对象之间的依赖，实现解耦。中介者就像是对象之间的调停者，协助对象間的交流与相互操作。
总体上，中介者模式可以使原本相互耦合的对象变成松散耦合，提高了灵活性和可维护性。中介者对象承担了对象間交互的责任，每个对象只需关注自身的行为和逻辑，不再与其他对象直接交互。
二、UML类图
三、角色设计
| 角色 | 描述 |
|---|---|
| 抽象中介者 | 定义接口用于与各同事对象通信 |
| 抽象同事 | 相关对象之间通信的对象，它们之间的通信必须通过中介者对象进行 |
| 具体中介者 | 实现中介者的接口，它需要知道所有同事类，并接受同事对象的通知，然后调用同事对象的方法 |
| 具体同事类 | 实现同事的接口，每一个同事类只知道自己的行为，而不了解其他同事类的情况，但是它们可以通过中介者联系其他对象 |
四、案例分析
下面通过代码实现了一个使用中介者模式的聊天程序的示例：
定义抽象聊天中介者角色：
public interface ChatMediator {
public void sendMessage(String msg, User user);
public void registerUser(User user);
}实现具体的聊天中介者：
import java.util.ArrayList;
import java.util.List;
public class ChatMediatorImpl implements ChatMediator {
private List<User> users = new ArrayList<>();
@Override
public void sendMessage(String msg, User user) {
for(User u : this.users) {
if(u != user) {
u.receiveMessage(msg);
}
}
}
@Override
public void registerUser(User user) {
this.users.add(user);
}
}定义抽象用户：
public abstract class User {
private String name;
private ChatMediator mediator;
public User(String name, ChatMediator mediator) {
this.name = name;
this.mediator = mediator;
}
public ChatMediator getChatMediator() {
return mediator;
}
public String getName() {
return name;
}
public abstract void sendMessage(String msg);
public abstract void receiveMessage(String msg);
}分别实现具体的用户，Mike和Jack：
public class Mike extends User{
public Mike(String name, ChatMediator mediator) {
super(name, mediator);
}
@Override
public void sendMessage(String msg) {
this.getChatMediator().sendMessage(msg, this);
}
@Override
public void receiveMessage(String msg) {
System.out.println(this.getName() + "收到信息: " + msg);
}
}
public class Jack extends User{
public Jack(String name, ChatMediator mediator) {
super(name, mediator);
}
@Override
public void sendMessage(String msg) {
this.getChatMediator().sendMessage(msg, this);
}
@Override
public void receiveMessage(String msg) {
System.out.println(this.getName() + "收到信息: " + msg);
}
}
客户端：
public class Client {
public static void main(String[] args) {
// 初始化中介者
ChatMediator mediator = new ChatMediatorImpl();
// 初始化用户
User user1 = new Mike("Mike", mediator);
User user2 = new Jack("Jack", mediator);
// 注册用户
mediator.registerUser(user1);
mediator.registerUser(user2);
// 用户互相通信
user1.sendMessage("你好，我是Mike!");
user2.sendMessage("你好，我是Jack!");
}
}
运行结果如下：
整体实现如下：
1、ChatMediator接口定义了中介者的角色，包含sendMessage和registerUser两个方法。
2、ChatMediatorImpl实现了ChatMediator接口，作为具体的中介者实现。它维护了一个用户列表users，并在sendMessage方法中遍历该列表，将消息转发给除发送用户外的其他用户。
3、User类定义了用户的抽象类，持有中介者对象的引用。它有两个抽象方法sendMessage和receiveMessage。
4、Jack和Mike类继承自User类，实现了sendMessage和receiveMessage方法，通过中介者的引用调用其方法来发送和接收消息。
5、Client类充当客户端角色，创建中介者和用户对象，建立他们之间的关系，并触发他们之间的交互 - 互相发送消息。
总体上，这段代码通过中介者模式实现了用户对象之间的解耦。用户对象不再直接交互，而是通过中介者转发消息。这使得用户对象可以独立变化，新增用户很方便，只需要注册到中介者即可。也遵循了单一职责原则，用户对象只负责自身消息发送接收，中介者负责协调转发。
五、总结
优点：
1、降低了对象之间的耦合度。对象之间不再直接交互，它们仅需要保持与中介者的依赖关系即可。
2、提高了系统的灵活性。可以独立地改变对象之间的交互。只需要调整中介者的逻辑，不需要修改对象本身。
3、简化了对象。对象本身只需要关注自身的行为逻辑，不需要处理与其他对象的交互关系。
4、提高了复用性。可以复用中介者类，而不需要了解其内部工作机制。
缺点：
1、中介者会变得过于复杂。中介者需要处理所有对象之间的交互，这使得它经常成为一个庞大的类。
2、依赖中介者。整个系统依赖于中介者，一旦中介者发生问题，会影响到所有交互对象。
应用场景：
1、系统中对象间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
2、一个对象由于引用其他很多对象，导致难以复用该对象。 -想通过一个中间类消除对象之间的紧耦合关系。
符合的设计原则：
1、单一职责原则（Single Responsibility Principle）
中介者专注于对象之间的交互，对象专注于自身的行为和状态，符合单一职责原则。
2、开闭原则（Open Closed Principle）
可以在不修改对象自身的情况下，通过扩展中介者来改变对象交互，符合开闭原则。
3、依赖倒置原则（Dependency Inversion Principle）
对象依赖于中介者接口，而不是具体的中介者类，符合依赖倒置原则。
4、接口隔离原则（Interface Segregation Principle）
中介者模式通过接口定义对象对外交互，符合接口隔离原则，防止污染不需要的接口。
