当前位置: 首页 > article >正文

【设计模式】【行为型模式】中介者模式(Mediator)

👋hi,我不是一名外包公司的员工,也不会偷吃茶水间的零食,我的梦想是能写高端CRUD
🔥 2025本人正在沉淀中… 博客更新速度++
👍 欢迎点赞、收藏、关注,跟上我的更新节奏
🎵 当你的天空突然下了大雨,那是我在为你炸乌云

文章目录

  • 一、入门
    • 什么是中介者模式?
    • 为什么要中介者模式?
    • 怎么实现中介者模式?
  • 二、中介者模式在框架源码中的运用
    • Java 中的 java.util.Timer
    • Spring 框架中的 ApplicationContext
  • 三、总结
    • 中介者模式的优点
    • 中介者模式的缺点
    • 中介者模式的适用场景
  • 参考

一、入门

什么是中介者模式?

中介者模式(Mediator Pattern)是一种行为设计模式,旨在减少对象之间的直接依赖,通过引入一个中介者对象来协调多个对象之间的交互。这种模式特别适用于对象间存在复杂交互的场景,能够简化系统结构并降低耦合。
中介者模式的核心是封装对象间的交互,避免对象直接相互调用,而是通过中介者进行通信。这样,对象只需与中介者交互,而不需要知道其他对象的存在。

为什么要中介者模式?

假设有一个聊天室系统,多个用户(User)之间可以直接发送消息。如果没有中介者模式,用户之间会直接相互依赖:

class User {
    private String name;

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

    public void sendMessage(String message, User receiver) {
        System.out.println(name + " sends: " + message);
        receiver.receiveMessage(message, this);
    }

    public void receiveMessage(String message, User sender) {
        System.out.println(name + " received from " + sender.name + ": " + message);
    }
}

public class ChatRoomWithoutMediator {
    public static void main(String[] args) {
        User alice = new User("Alice");
        User bob = new User("Bob");
        User charlie = new User("Charlie");

        alice.sendMessage("Hi Bob!", bob);
        bob.sendMessage("Hello Alice!", alice);
        charlie.sendMessage("Hey everyone!", alice); // 需要手动发送给每个人
    }
}

在没有中介者模式的情况下,对象之间通常会直接相互调用和依赖,导致以下问题:

  1. 对象间耦合度高:
    ○ 每个对象都需要知道其他对象的存在,并直接调用它们的方法。
    ○ 如果对象间的关系复杂,依赖会变得混乱,难以维护。
  2. 交互逻辑分散:
    ○ 对象间的交互逻辑分散在各个对象中,导致代码重复且难以管理。
    ○ 修改一个对象的逻辑可能会影响其他多个对象。
  3. 系统难以扩展:
    ○ 新增或修改对象时,可能需要修改多个相关对象的代码。
    ○ 系统的可扩展性和灵活性较差。
  4. 难以理解和维护:
    ○ 对象间的直接依赖关系使得代码难以理解,尤其是在对象数量多、交互复杂的情况下。

怎么实现中介者模式?

在中介者模式中有如下角色:

  • Mediator(中介者接口):定义对象间通信的接口。
  • ConcreteMediator(具体中介者):实现中介者接口,协调各对象间的交互。
  • Colleague(同事类):定义各个对象的接口,每个同事类都知道中介者,并通过中介者与其他对象通信。
  • ConcreteColleague(具体同事类):实现同事类接口,与其他对象通过中介者交互。

【案例】聊天室 - 改
在这里插入图片描述
Mediator(中介者接口)ChatMediator接口

interface ChatMediator {
    void sendMessage(String message, User sender);
    void addUser(User user);
}

ConcreteMediator(具体中介者)ChatRoom

class ChatRoom implements ChatMediator {
    private List<User> users = new ArrayList<>();

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

    @Override
    public void sendMessage(String message, User sender) {
        for (User user : users) {
            if (user != sender) { // 不发送给自己
                user.receiveMessage(message);
            }
        }
    }
}

Colleague(同事类)User

class User {
    private String name;
    private ChatMediator mediator;

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

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

    public void receiveMessage(String message) {
        System.out.println(name + " received: " + message);
    }
}

测试类

public class ChatRoomWithMediator {
    public static void main(String[] args) {
        ChatMediator chatRoom = new ChatRoom();

        User alice = new User("Alice", chatRoom);
        User bob = new User("Bob", chatRoom);
        User charlie = new User("Charlie", chatRoom);

        chatRoom.addUser(alice);
        chatRoom.addUser(bob);
        chatRoom.addUser(charlie);

        alice.sendMessage("Hi everyone!");
        bob.sendMessage("Hello Alice!");
    }
}

二、中介者模式在框架源码中的运用

Java 中的 java.util.Timer

Timer类可以看作是一个中介者,它负责调度和管理多个TimerTask对象。TimerTask是具体的同事类,它们通过Timer来协调任务的执行。

  • Timer 作为中介者,负责调度和执行任务。
  • TimerTask 不需要知道其他任务的存在,只需通过Timer来安排自己的执行。
import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer(); // 中介者

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task 1 is running.");
            }
        };

        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task 2 is running.");
            }
        };

        // 通过中介者安排任务
        timer.schedule(task1, 1000); // 1秒后执行
        timer.schedule(task2, 2000); // 2秒后执行
    }
}

Spring 框架中的 ApplicationContext

在 Spring 框架中,ApplicationContext可以看作是一个中介者,它负责管理 Bean 的创建、依赖注入和生命周期。

  • ApplicationContext 作为中介者,集中管理所有 Bean 的交互。
  • Bean 之间不需要直接依赖,而是通过 ApplicationContext 获取依赖。
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

class ServiceA {
    public void doSomething() {
        System.out.println("Service A is doing something.");
    }
}

class ServiceB {
    private final ServiceA serviceA;

    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public void doSomething() {
        System.out.println("Service B is doing something.");
        serviceA.doSomething();
    }
}

public class SpringExample {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        ServiceB serviceB = context.getBean(ServiceB.class);
        serviceB.doSomething();
    }
}

三、总结

中介者模式的优点

  • 降低耦合度
    • 对象之间不再直接依赖,而是通过中介者进行通信。
    • 每个对象只需知道中介者,而不需要知道其他对象的存在。
  • 集中管理交互逻辑
    • 对象间的交互逻辑集中在中介者中,避免了逻辑分散。
    • 修改交互逻辑时,只需修改中介者,而不需要修改各个对象。
  • 提高系统的可扩展性
    • 新增对象时,只需修改中介者,而不需要修改现有对象。
    • 系统的扩展性和灵活性得到提升。
  • 简化代码结构
    • 对象间的依赖关系变得清晰,代码更易于理解和维护。
  • 增强可维护性
    • 由于交互逻辑集中在中介者中,调试和维护更加方便。

中介者模式的缺点

  • 中介者可能变得复杂
    • 如果对象间交互复杂,中介者可能会变得庞大且难以维护。
    • 中介者承担了过多的职责,可能违反单一职责原则。
  • 性能瓶颈
    • 所有交互都通过中介者进行,可能导致中介者成为性能瓶颈。
  • 过度集中化
    • 中介者集中了所有交互逻辑,可能导致系统过度依赖中介者,难以拆分或重构。

中介者模式的适用场景

  • 对象间交互复杂
    • 当多个对象之间存在复杂的交互关系,直接依赖会导致耦合度过高时,适合使用中介者模式。
  • 需要集中管理交互逻辑
    • 当对象间的交互逻辑分散在各个对象中,难以维护时,可以通过中介者集中管理。
  • 需要解耦对象间的依赖
    • 当对象之间需要解耦,避免直接依赖时,中介者模式是一个很好的选择。
  • 适用于事件驱动系统
    • 在事件驱动系统中,中介者可以充当事件分发器,集中管理事件的传递和处理。
  • GUI 开发
    • 在 GUI 开发中,中介者模式常用于管理组件间的交互,例如按钮点击、输入框变化等。
  • 多对多通信场景
    • 当多个对象需要相互通信,且通信关系复杂时,中介者模式可以简化通信逻辑。

参考

黑马程序员Java设计模式详解, 23种Java设计模式(图解+框架源码分析+实战)_哔哩哔哩_bilibili


http://www.kler.cn/a/550041.html

相关文章:

  • Python 实用技巧:如何使用 Python 进行批量邮件自动化
  • 网络安全PPDR
  • Jenkins 配置 Git Parameter 四
  • 【kafka系列】生产者
  • Qt中基于开源库QRencode生成二维码(附工程源码链接)
  • 算法-哈希表篇02-两个数组的交集
  • 设计模式:状态模式
  • Linux alias使用
  • 人工智能 - 机器学习、深度学习、强化学习是人工智能领域的理论基础和方法论
  • LLM:GPT 系列
  • wed前端:实现页面中可以拖动的登录窗口
  • Flutter 添加 iOS widget 小组件
  • hbase合并队列超长问题分析
  • Word中打开开发工具【修改日期控件显示格式】
  • API网关基础知识总结
  • 前端知识速记—JS篇:JS数组方法
  • Word 里面嵌入DeepSeek
  • 高效构建与配置高可用负载均衡集群:从理论到实践的全面实施
  • 【落羽的落羽 数据结构篇】双向链表
  • 第四期书生大模型实战营-第5关-L2G5000