当前位置：首页 > wzjs >正文

建设厅网站业绩备案公示期成都网站建设公司

wzjs 2025/7/22 16:52:22

建设厅网站业绩备案公示期,成都网站建设公司,做网站知名公司,广州注册公司无地址怎么办👋hi，我不是一名外包公司的员工，也不会偷吃茶水间的零食，我的梦想是能写高端CRUD 🔥 2025本人正在沉淀中… 博客更新速度 👍 欢迎点赞、收藏、关注，跟上我的更新节奏 🎵 当你的天空突…

👋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); // 需要手动发送给每个人}
}

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

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

怎么实现中介者模式？

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

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<>();@Overridepublic void addUser(User user) {users.add(user);}@Overridepublic 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() {@Overridepublic void run() {System.out.println("Task 1 is running.");}};TimerTask task2 = new TimerTask() {@Overridepublic 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();}
}