资讯

历史

科技

环境与自然

成长

游戏

财经

文学与艺术

美食

健康

家居

文化

情感

汽车

三农

军事

旅行

运动

教育

生活

星座命理

中介者模式（Mediator）详解：定义、实现及框架应用

创作时间:

作者:

@小白创作中心

中介者模式（Mediator）详解：定义、实现及框架应用

引用

CSDN

https://blog.csdn.net/flzjcsg3/article/details/145603551

中介者模式（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（中介者接口）：

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

ConcreteMediator(具体中介者)：

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（同事类）：

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();
    }
}