中介者模式（Mediator Pattern）

中介者模式是一种行为型设计模式，它通过引入一个中介者对象来封装一系列对象之间的交互。中介者模式减少了对象之间的直接依赖，使得对象之间的耦合度降低，从而使得系统更易于维护和扩展。

模式结构

1. 中介者接口（Mediator）
   定义与组件进行交互的方法，组件可以通过这些方法与中介者通信。
2. 具体中介者（Concrete Mediator）
   实现中介者接口，负责协调各个组件之间的交互。它通常持有所有组件的引用，并管理它们之间的关系。
3. 组件类（Colleague）
   定义组件的通用接口，组件通常持有一个中介者的引用，并通过中介者与其他组件通信。
4. 具体组件（Concrete Colleague）
   实现组件接口，负责具体的业务逻辑。它通过中介者与其他组件通信，而不是直接与其他组件交互。

代码示例

1. 中介者接口（Mediator）

// 中介者接口：定义与组件进行交互的方法
interface Mediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

2. 具体中介者（Concrete Mediator）

// 具体中介者：实现中介者接口
class ChatMediator implements Mediator {
    private final List<User> users;

    public ChatMediator() {
        users = new ArrayList<>();
    }

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receive(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

3. 组件类（Colleague）

// 组件类：定义组件的通用接口
abstract class User {
    protected Mediator mediator;
    protected String name;

    public User(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

4. 具体组件（Concrete Colleague）

// 具体组件：实现组件接口
class ChatUser extends User {
    public ChatUser(Mediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void send(String message) {
        System.out.println("[" + this.name + "] Sending Message : " + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("[" + this.name + "] Received Message : " + message);
    }
}

5.调用示例

public class MediatorPattern {
    public static void main(String[] args) {
        Mediator mediator = new ChatMediator();
        User user1 = new ChatUser(mediator, "Jack");
        User user2 = new ChatUser(mediator, "Jenny");
        User user3 = new ChatUser(mediator, "Kay");
        User user4 = new ChatUser(mediator, "Machine");

        mediator.addUser(user1);
        mediator.addUser(user2);
        mediator.addUser(user3);
        mediator.addUser(user4);

        user1.send("Hello every one!");
    }
}

输出结果

[Jack] Sending Message : Hello every one!
[Jenny] Received Message : Hello every one!
[Kay] Received Message : Hello every one!
[Machine] Received Message : Hello every one!

应用场景

1. 减少对象之间的直接依赖
   当对象之间的依赖关系过于复杂时，可以使用中介者模式来减少对象之间的直接依赖，使得系统更易于维护。
2. 集中管理对象之间的交互
   当需要集中管理多个对象之间的交互时，可以使用中介者模式。中介者可以封装对象之间的交互逻辑，使得交互逻辑更易于理解和维护。
3. 动态调整对象之间的交互
   当需要在运行时动态调整对象之间的交互方式时，可以使用中介者模式。中介者可以在运行时改变对象之间的交互逻辑。

在Java中的应用

• java.util.Timer
Timer 类可以看作是一个中介者，它负责调度任务并协调任务的执行。
• java.util.concurrent.Executor
Executor 接口及其实现类（如 ThreadPoolExecutor）可以看作是一个中介者，它负责管理线程池中的任务执行。
• java.lang.reflect.Method
Method 类的 invoke() 方法可以看作是一个中介者，它负责调用目标对象的方法。

优缺点

优点

1. 减少对象之间的耦合
   中介者模式通过引入中介者对象，减少了对象之间的直接依赖，使得系统更易于维护。
2. 集中管理交互逻辑
   中介者模式将对象之间的交互逻辑集中在中介者中，使得交互逻辑更易于理解和维护。
3. 动态调整交互方式
   中介者模式允许在运行时动态调整对象之间的交互方式，增加了系统的灵活性。

缺点

1. 中介者可能变得复杂
   如果对象之间的交互逻辑非常复杂，中介者可能会变得过于庞大和复杂，难以维护。
2. 中介者可能成为单点故障
   中介者负责管理所有对象之间的交互，如果中介者出现问题，可能会影响整个系统的正常运行。

总结

中介者模式通过引入中介者对象来封装对象之间的交互，减少了对象之间的直接依赖，使得系统更易于维护和扩展。它适用于需要减少对象之间耦合、集中管理交互逻辑或动态调整交互方式的场景。尽管它可能会增加中介者的复杂性，但其优点在于提高了系统的灵活性和可维护性。在Java中，中介者模式广泛应用于任务调度和线程池管理等场景。