设计模式-中介者模式

中介者模式：

中介者模式（Mediator Pattern）是属于行为结构类型的设计模式，它旨在通过引入一个中介对象来明确多个对象之间的交互关系。在没有中介者的情况下，系统中的多个对象之间可能存在复杂的相互依赖和直接通信，这会导致高度耦合、难以理解和维护的代码结构。

主要角色：

1 Mediator（抽象中介者）：

定义了与各同事对象（Colleague）进行通信的接口，让同事对象可以调用 mediator 的方法。
通常包含一组用于注册同事对象的方法以及一些处理交互逻辑的抽象方法。

2 ConcreteMediator（具体中介者）：

具体实现了中介者接口，负责协调各个同事对象之间的交互，掌握所有同事对象的引用并实现具体的交互逻辑。
当同事对象间需要通信时，它们会调用具体中介者的相应方法，而不与其他同事对象通信。

3 Colleague（同事类）：

同事类是参与交互的对象，每个同事类都知道中介者，并通过中介者与其他同事类通信。
同事类通常定义一个指向中介者的引用，并提供用于通知中介者状态变化的方法。

工作原理：

当同事对象之间需要交流时，它们不直接互相调用方法，而是通过调用中介者的方法来间接传递消息。
中介者收到请求后，根据内部逻辑决定如何协调不同同事对象的行为，从而改变系统的状态或执行特定操作。

示例代码：

中介者模式java示例代码：

java 复制代码

// 抽象同事类（Colleague）
public abstract class User {
    protected ChatRoomMediator mediator;

    public void setMediator(ChatRoomMediator mediator) {
        this.mediator = mediator;
    }

    // 用户发送消息的方法，实际操作交给中介者处理
    public abstract void sendMessage(String message);
}

// 具体同事类（Concrete Colleague）
public class ConcreteUser extends User {
    private String name;

    public ConcreteUser(String name, ChatRoomMediator mediator) {
        super();
        this.name = name;
        this.setMediator(mediator);
    }

    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(this, message);
    }
    
    public String getName() {
        return name;
    }
}

// 抽象中介者类（Mediator）
public interface ChatRoomMediator {
    void sendMessage(User user, String message);
}

// 具体中介者类（Concrete Mediator）
public class ChatRoom implements ChatRoomMediator {
    private List<User> users;

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

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

    @Override
    public void sendMessage(User user, String message) {
        System.out.println(user.getName() + " says: " + message);
        for (User recipient : users) {
            if (recipient != user) { // 不向自己发送消息
                recipient.receiveMessage(user.getName(), message);
            }
        }
    }
}

// 为了简化示例，这里直接在用户类中添加接收消息的方法
public abstract class User {
    // ... 其他已有方法

    // 添加一个抽象的接收消息的方法，在具体子类中实现
    public abstract void receiveMessage(String from, String message);
}

// 具体同事类中实现接收消息的方法
public class ConcreteUser extends User {
    // ... 已有构造函数和sendMessage方法

    @Override
    public void receiveMessage(String from, String message) {
        System.out.println("Received message from " + from + ": " + message);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ChatRoomMediator mediator = new ChatRoom();

        User user1 = new ConcreteUser("Alice", mediator);
        User user2 = new ConcreteUser("Bob", mediator);

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

        user1.sendMessage("Hello Bob!");
        user2.sendMessage("Hi Alice!");
    }
}

说明：在上面代码中ChatRoom 是中介者，它管理着所有 ConcreteUser 对象，并负责转发消息。当一个用户发送消息时，它通过调用中介者的 sendMessage 方法，而不是直接与其他用户通信。这样就实现了对象间的解耦。

优点：

降低耦合度：通过将对象间的复杂关联关系集中到中介者中，减少对象间的直接依赖。
可扩展性增强：当新同事对象加入系统只需修改中介者的逻辑，不需改动已有的同事对象。
更容易复用：中介者封装了对象间交互的复杂性，使得单个对象的行为更易于复用和理解。

应用场景：

GUI 应用程序框架，如事件分发器管理用户界面组件之间的交互。
多模块通信系统，例如模块化软件架构中不同模块间的通信控制。
网络协议栈中，交换机作为各个网络节点之间的中介者，处理数据包转发等任务。