设计模式精讲 Day 17：中介者模式（Mediator Pattern）

【设计模式精讲 Day 17】中介者模式（Mediator Pattern）

文章内容

开篇：Day 17 —— 中介者模式的核心思想与应用价值

在“设计模式精讲”系列的第17天，我们聚焦于中介者模式（Mediator Pattern）。这是一种行为型设计模式，旨在通过一个中介对象来封装多个对象之间的交互逻辑，从而降低对象间的耦合度。

中介者模式特别适用于复杂的系统中，当多个对象之间存在频繁的通信和依赖关系时，使用中介者可以简化系统的结构，提高可维护性和扩展性。例如，在GUI界面中，多个组件之间的交互可以通过中介者统一管理；在分布式系统中，多个服务之间的通信也可以通过中介者进行协调。

本节将深入讲解中介者模式的定义、结构、适用场景、实现方式、工作原理、优缺点分析以及实际项目中的应用案例，帮助读者掌握如何在实际开发中灵活运用这一模式。

模式定义

中介者模式是一种行为型设计模式，它通过引入一个中介对象来封装一组对象之间的交互逻辑，使得这些对象无需直接相互引用，而是通过中介者进行通信。

核心思想是：解耦对象之间的直接依赖，由中介者负责协调各对象之间的交互。

模式结构

中介者模式包含以下关键角色：

适用场景

中介者模式适用于以下场景：

• 多个对象之间存在复杂的交互关系。
• 对象之间的通信逻辑复杂，难以维护。
• 需要集中管理对象之间的通信逻辑，提高系统的可维护性。
• 在 GUI 界面中，多个组件之间的交互可以通过中介者统一管理。
• 在分布式系统中，多个服务之间的通信可以通过中介者进行协调。

实现方式

下面是一个完整的 Java 实现示例，展示了如何使用中介者模式实现两个同事对象之间的通信。

// 1. 定义中介者接口
interface Mediator {
    void send(String message, Colleague colleague);
}

// 2. 定义同事抽象类
abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void receive(String message);
}

// 3. 具体同事A
class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void receive(String message) {
        System.out.println("Colleague A received: " + message);
    }

    public void send(String message) {
        mediator.send(message, this);
    }
}

// 4. 具体同事B
class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void receive(String message) {
        System.out.println("Colleague B received: " + message);
    }

    public void send(String message) {
        mediator.send(message, this);
    }
}

// 5. 具体中介者
class ConcreteMediator implements Mediator {
    private ConcreteColleagueA colleagueA;
    private ConcreteColleagueB colleagueB;

    public ConcreteMediator(ConcreteColleagueA colleagueA, ConcreteColleagueB colleagueB) {
        this.colleagueA = colleagueA;
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else {
            colleagueA.receive(message);
        }
    }
}

// 6. 使用示例
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ConcreteColleagueA a = new ConcreteColleagueA(null);
        ConcreteColleagueB b = new ConcreteColleagueB(null);

        Mediator mediator = new ConcreteMediator(a, b);

        a.mediator = mediator;
        b.mediator = mediator;

        a.send("Hello from A");
        b.send("Hello from B");
    }
}

代码说明

• Mediator 接口定义了发送消息的方法。
• Colleague 抽象类提供了对中介者的引用，并定义了接收消息的抽象方法。
• ConcreteColleagueA 和 ConcreteColleagueB 是具体的同事类，它们通过中介者与其他同事通信。
• ConcreteMediator 实现了中介者的接口，负责协调两个同事之间的通信。

工作原理

中介者模式通过引入一个中介对象，将原本分散在多个对象之间的通信逻辑集中到中介者中，从而实现了对象之间的解耦。

其底层机制如下：

1. 对象间不再直接通信：每个对象只与中介者通信，而不与其他对象直接交互。
2. 中介者协调通信：中介者根据不同的对象类型，将消息转发给正确的接收方。
3. 降低耦合度：由于对象之间没有直接依赖，系统的可维护性和可扩展性得到提升。

优缺点分析

案例分析：GUI界面中的按钮与文本框通信

问题描述

在一个简单的 GUI 界面中，有多个按钮和一个文本框。点击按钮会更新文本框的内容。如果直接让按钮与文本框通信，会导致两者之间产生强耦合。

解决方案

使用中介者模式，让按钮和文本框都通过中介者进行通信。

// 1. 定义中介者接口
interface GuiMediator {
    void updateText(String text);
}

// 2. 定义按钮抽象类
abstract class Button {
    protected GuiMediator mediator;

    public Button(GuiMediator mediator) {
        this.mediator = mediator;
    }

    public abstract void onClick();
}

// 3. 定义文本框
class TextField {
    private String content;

    public void setContent(String content) {
        this.content = content;
        System.out.println("TextField content: " + content);
    }
}

// 4. 具体按钮A
class ButtonA extends Button {
    public ButtonA(GuiMediator mediator) {
        super(mediator);
    }

    @Override
    public void onClick() {
        mediator.updateText("Button A clicked");
    }
}

// 5. 具体按钮B
class ButtonB extends Button {
    public ButtonB(GuiMediator mediator) {
        super(mediator);
    }

    @Override
    public void onClick() {
        mediator.updateText("Button B clicked");
    }
}

// 6. 具体中介者
class GuiMediatorImpl implements GuiMediator {
    private TextField textField;

    public GuiMediatorImpl(TextField textField) {
        this.textField = textField;
    }

    @Override
    public void updateText(String text) {
        textField.setContent(text);
    }
}

// 7. 使用示例
public class GuiMediatorDemo {
    public static void main(String[] args) {
        TextField textField = new TextField();
        GuiMediator mediator = new GuiMediatorImpl(textField);

        Button buttonA = new ButtonA(mediator);
        Button buttonB = new ButtonB(mediator);

        buttonA.onClick();
        buttonB.onClick();
    }
}

效果

• 按钮和文本框之间不再直接通信，降低了耦合度。
• 中介者统一管理通信逻辑，提高了系统的可维护性。

与其他模式的关系

1. 与观察者模式（Observer Pattern）的区别

• 观察者模式强调的是对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知。
• 中介者模式则强调的是集中式通信，所有通信都通过中介者进行。

适用场景对比：

• 观察者模式适合事件驱动的系统，如 GUI 事件、消息推送等。
• 中介者模式适合需要集中管理通信逻辑的系统，如 GUI 组件交互、微服务通信等。

2. 与策略模式（Strategy Pattern）的结合使用

中介者模式可以与策略模式结合使用，通过中介者动态选择不同的通信策略。例如，可以在中介者中配置不同的通信算法，以适应不同的业务需求。

总结

本节详细介绍了中介者模式（Mediator Pattern），包括其定义、结构、适用场景、实现方式、工作原理、优缺点分析以及实际项目中的应用案例。通过学习该模式，读者可以理解如何在复杂的系统中降低对象之间的耦合度，提高系统的可维护性和扩展性。

下一日预告

在接下来的 Day 18 中，我们将介绍 备忘录模式（Memento Pattern），它用于在不破坏封装性的前提下，捕获并恢复对象的状态。这在实现撤销操作、版本控制等场景中非常有用。

文章标签

design-patterns, mediator-pattern, java-design-patterns, object-oriented-programming, software-architecture, code-examples, design-patterns-in-java, software-engineering, gui-development, system-design

文章简述

本文围绕 中介者模式（Mediator Pattern） 展开，从基本概念入手，逐步深入讲解其技术原理、应用场景、实现方式及实际项目案例。文章提供了完整的代码示例和真实项目案例，帮助读者理解如何在实际开发中使用中介者模式降低对象之间的耦合度，提高系统的可维护性和扩展性。同时，文章还对比了该模式与其他设计模式的异同，为开发者提供实用的调优指南。对于希望提升系统架构设计能力的Java开发人员来说，本文具有重要的参考价值。