Java设计模式二十一中介者模式 (Mediator Pattern)

最新推荐文章于 2025-12-28 16:49:38 发布

原创最新推荐文章于 2025-12-28 16:49:38 发布 · 726 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #中介者模式

设计模式专栏收录该内容

36 篇文章

订阅专栏

中介者模式 (Mediator Pattern)

中介者模式是一种行为型设计模式，它用于降低多个对象和类之间的通信复杂性。中介者模式通过引入一个中介者对象，使得原本直接通信的对象不再相互直接交互，而是通过中介者来进行协调和通信。这样，所有对象只需要与中介者对象交互，而不再直接依赖于其他对象。中介者模式的关键思想是：通过一个中介者对象来集中管理和协调各个对象之间的交互，避免了对象之间的直接耦合。

1. 中介者模式的组成

中介者模式通常包含以下几个角色：

Mediator（中介者接口）：定义了与各个同事类（Colleague）交互的接口。中介者通常负责协调不同同事类之间的通信。
ConcreteMediator（具体中介者）：实现了Mediator接口，并协调不同的同事类（Colleague）之间的交互。具体中介者持有所有同事类的引用，并通过这些引用来调度相关操作。
Colleague（同事类）：每个同事类都知道中介者的存在，并通过中介者与其他同事类交互。每个同事类通常会将自己的一些操作委托给中介者来处理。

2. 中介者模式的工作流程

各个同事类（Colleague）在需要与其他同事类交互时，并不直接交互，而是通过中介者来完成。
中介者接收到同事类的请求后，协调其他同事类的行为或通知其他相关同事类。
同事类之间的交互通过中介者来管理，从而减少了同事类之间的直接耦合，使得系统更加灵活和可维护。

3. 中介者模式的实现

场景示例：聊天系统

假设我们设计一个简单的聊天系统，其中有多个用户，每个用户都可以发送消息给其他用户，但我们不希望每个用户直接与其他用户进行通信，而是通过一个中介者来协调消息的发送和接收。我们可以使用中介者模式来实现这一功能。

1) 定义中介者接口

Mediator接口定义了与同事类交互的方法。

// 中介者接口
public interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

2) 定义同事类接口

Colleague类是一个抽象类，表示系统中的每个用户。

// 同事类接口
public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void receiveMessage(String message);
}

3) 定义具体的同事类

User类表示具体的聊天用户，每个用户都可以发送和接收消息。

// 具体同事类：用户
public class User extends Colleague {

    private String name;

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

    public String getName() {
        return name;
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(name + " 收到消息: " + message);
    }

    public void sendMessage(String message) {
        System.out.println(name + " 发送消息: " + message);
        mediator.sendMessage(message, this);
    }
}

4) 定义具体的中介者类

ChatRoom类是具体的中介者，它负责协调不同用户之间的消息传递。

// 具体中介者类：聊天室
public class ChatRoom implements Mediator {

    private List<Colleague> colleagues;

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

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receiveMessage(message);
            }
        }
    }
}

5) 客户端代码

客户端代码创建多个用户，并通过聊天室中介者来发送和接收消息。

public class Client {
    public static void main(String[] args) {
        // 创建中介者（聊天室）
        ChatRoom chatRoom = new ChatRoom();

        // 创建用户，并将他们加入聊天室
        User user1 = new User(chatRoom, "张三");
        User user2 = new User(chatRoom, "李四");
        User user3 = new User(chatRoom, "王五");

        chatRoom.addColleague(user1);
        chatRoom.addColleague(user2);
        chatRoom.addColleague(user3);

        // 用户发送消息
        user1.sendMessage("大家好！");

        // 另一位用户发送消息
        user2.sendMessage("你好，张三！");
    }
}

运行结果：

张三 发送消息: 大家好！
李四 收到消息: 大家好！
王五 收到消息: 大家好！
李四 发送消息: 你好，张三！
张三 收到消息: 你好，张三！
王五 收到消息: 你好，张三！

4. 中介者模式的优点

减少类与类之间的依赖关系： 各个同事类之间不再直接通信，而是通过中介者来协调，从而减少了类之间的耦合性。
集中管理交互： 交互的逻辑都集中在中介者中，使得修改和维护变得更加简单。
更易扩展： 增加新的同事类时，只需要将新的同事类添加到中介者中，而不需要修改现有的类。
职责分离： 中介者模式将同事类的交互逻辑从业务逻辑中提取出来，职责更加清晰。

5. 中介者模式的缺点

中介者对象变得复杂： 随着同事类的增多，中介者对象需要处理的交互逻辑也会变得复杂，可能导致中介者类的过度膨胀。
潜在的性能问题： 由于所有通信都通过中介者进行，可能会引入性能瓶颈，尤其是在大量同事类间交互的场景下。
增加了额外的抽象层次： 引入中介者后，可能会增加系统的复杂度和抽象层次，导致代码的理解和维护成本提高。

6. 中介者模式的应用场景

GUI组件间的交互： 在复杂的图形界面中，不同的组件（如按钮、文本框等）需要相互协调，使用中介者模式可以避免它们之间的直接交互。
系统中的消息中转： 比如在社交网络或聊天室中，消息的传递可以通过中介者来协调，减少直接耦合。
工作流引擎： 在一些复杂的工作流或任务流中，各个模块之间需要进行协作，可以通过中介者模式来控制各个模块的交互。

7. 总结

中介者模式通过引入中介者对象，减少了系统中各个同事类之间的直接依赖，简化了类与类之间的交互。它使得系统更加灵活，可维护性更高。虽然中介者模式提高了系统的可扩展性，但也可能导致中介者本身变得复杂，因此需要合理使用，尤其是在交互较为复杂的系统中。