设计模式十八：中介者模式（Mediator Pattern）

在中介者模式中，多个对象之间不再直接相互通信，而是通过一个中介者对象进行通信。这可以减少对象之间的依赖关系，使系统更加模块化。中介者模式适用于当对象之间的通信逻辑变得复杂，导致代码难以维护和理解时。

中介者模式使用场景

1. 对象之间的交互复杂度高
   当系统中的对象之间需要频繁地相互通信，导致交互逻辑复杂且难以维护时，可以考虑使用中介者模式来将这些复杂的交互逻辑集中管理。
2. 对象之间的耦合度高
   如果对象之间的耦合度过高，修改一个对象可能会影响到其他对象，使得系统难以扩展和维护。中介者模式可以降低对象之间的直接依赖关系，从而减少耦合度。
3. 分布式系统
   在分布式系统中，不同节点之间需要通信和协调。使用中介者模式可以在不同节点之间引入一个中介者，负责协调节点之间的通信，从而简化分布式系统的设计和管理。
4. 图形界面应用
   在图形界面应用中，各个界面元素之间需要相互响应和协调，例如按钮点击触发其他界面元素的更新。中介者模式可以用来管理界面元素之间的交互，避免它们之间的紧密耦合。
5. 多人协作系统
   在多人协作系统中，不同用户或角色之间需要相互协调和通信。中介者模式可以用于管理不同用户或角色之间的交互，确保协作流程的顺畅进行。
6. 消息传递系统
   当系统中需要实现消息传递和通信时，可以使用中介者模式来管理消息的发送和接收，确保消息传递的可靠性和一致性。
   中介者模式虽然有诸多优点，但在一些情况下可能会引入一个单点故障，即中介者本身出现问题可能会影响整个系统的功能。因此，在使用中介者模式时，需要谨慎权衡和设计中介者的职责和功能，确保模式的有效性和稳定性。

中介者模式的主要角色

中介者模式的核心思想是将对象之间的交互从彼此之间解耦，通过引入中介者来管理交互，从而使系统更加灵活、可维护和可扩展。这种模式的使用可以使得系统的交互逻辑变得更加清晰，并减少对象之间复杂的直接关联。

1. 中介者（Mediator）
   中介者是该模式的核心，负责定义对象之间的通信接口和协调规则。它持有对所有相关同事类对象的引用，并根据业务逻辑协调它们之间的交互。中介者通常封装了复杂的交互逻辑，使对象之间的通信更加简单和集中。
2. 同事类（Colleague）
   同事类是需要相互通信的对象，每个同事类都知道中介者对象并通过中介者来与其他同事类进行通信。同事类之间不直接通信，而是通过中介者进行交互，从而降低了对象之间的耦合度。
   在一些实现中，同事类可以分为两类：
   具体同事类（Concrete Colleague）
   具体同事类实现了同事类的接口，通过中介者与其他具体同事类进行通信。每个具体同事类通常只关心自己的业务逻辑，而将交互逻辑委托给中介者处理。
   抽象同事类（Abstract Colleague）
   抽象同事类定义了同事类的接口，通常包括一个指向中介者的引用。具体同事类通过继承抽象同事类来实现通信功能。

java代码实例

创建一个聊天室的场景，其中用户可以通过中介者给其它所有用户发送消息,或者接受其它用户发送的消息
中介者接口

//终结者接口
public interface ChatMediator {

    //添加用户
    void addUser(User user);

    void sendMessage(String message, User user);


}

中介者实现类

public class ChatMediatorImpl implements ChatMediator{

    //用户组
   private  List<User> users;

   //创建中介者的时候，初始化用户组
   public  ChatMediatorImpl(){
       this.users=new ArrayList<>();
   }


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

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


}

抽象用户

public interface User {

    //发送信息给中介
    void sendMassageToMe(String message);

    //接受消息
    void receiveMessage(String message);

}

具体用户

public class ConcreteUser implements User{

    private ChatMediator  chatMediator;
    private String name;

    public ConcreteUser(String name,ChatMediator  chatMediator){
        this.chatMediator=chatMediator;
        this.name= name;
        chatMediator.addUser(this);
    }

    @Override
    public void sendMassageToMe(String message) {
        System.out.println(name + " sends message: " + message);
        chatMediator.sendMessage(message,this);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(name+" receive a Message！"+message);
    }
}

客户端

public static void main(String[] args) {
    //初始化的时候就创建一个User组
    ChatMediator chatMediator = new ChatMediatorImpl();
    //创建三个用户，并且吧用户添加到了用户组中
    User user1 = new ConcreteUser("User 1", chatMediator);
    User user2 = new ConcreteUser("User 2", chatMediator);
    User user3 = new ConcreteUser("User 3", chatMediator);
    //用户发送消息
    user1.sendMassageToMe("Hello, everyone!");
    user2.sendMassageToMe("Hi there!");
}

运行结果

User 1 sends message: Hello, everyone!
User 2receive a Message！Hello, everyone!
User 3receive a Message！Hello, everyone!
User 2 sends message: Hi there!
User 1receive a Message！Hi there!
User 3receive a Message！Hi there!

中介者模式的优缺点

中介者模式在复杂的对象交互场景中可以提供许多优点，但在简单场景下可能会显得过于繁琐。使用中介者模式时，需要根据具体情况权衡其优缺点，确保模式的使用能够带来实际的设计和维护好处。
优点：

1. 降低耦合度：
   中介者模式可以减少对象之间的直接依赖关系，从而降低系统的耦合度。各个对象只需要和中介者进行通信，而不需要了解其他对象的详细信息。
2. 简化对象交互：
   中介者模式将复杂的交互逻辑集中在中介者中，使得对象之间的交互变得简单和集中。这有助于提高代码的可读性和维护性。
3. 集中管理：
   中介者模式可以集中管理对象之间的交互逻辑，使系统的逻辑更加清晰。通过将交互逻辑封装在中介者中，可以更容易地进行修改和扩展。
4. 易于扩展：
   当需要添加新的对象或修改交互规则时，只需修改中介者类，而不需要修改其他对象的代码。这使得系统更加容易扩展和维护。
5. 促进重用：
   中介者模式可以将交互逻辑从各个对象中抽取出来，使得这些逻辑可以被多个对象共享和重用。

缺点：

1. 中介者复杂：
   在某些情况下，中介者可能会变得复杂，尤其是当系统中有大量对象和复杂的交互逻辑时。这可能导致中介者本身难以维护。
2. 单点故障：
   中介者模式引入了一个中心化的中介者对象，如果这个中介者出现问题，可能会影响整个系统的功能。这可能会增加系统的脆弱性。
3. 通信间接性：
   中介者模式使得对象之间的通信变为间接的，可能会导致一些通信变得复杂，降低了部分直接性。
4. 不适用简单场景：
   在对象之间的交互相对简单的情况下，使用中介者模式可能会引入不必要的复杂性，增加代码的复杂度。