设计模式教程：中介者模式（Mediator Pattern）

用户12001855

发布于 2026-01-20 15:55:16

中介者模式是一种行为型设计模式，它用于减少对象之间的直接依赖关系。通过引入一个中介者对象，所有对象的交互都通过中介者进行，而不是直接相互通信。这种模式的主要目的是减少对象之间的耦合，提升系统的灵活性和可维护性。

1. 定义和意图

意图：中介者模式通过一个中介者对象来协调和控制多个对象之间的交互，从而减少多个对象之间的直接联系，降低系统的复杂度。对象通过中介者进行通信，而不直接依赖于彼此。

2. 组成部分

中介者模式通常由以下几个角色组成：

Mediator（中介者接口）：声明了一个方法，用于同事对象之间的通信。
ConcreteMediator（具体中介者）：实现中介者接口，负责协调同事对象之间的交互。
Colleague（同事类）：定义同事对象，所有对象与中介者的交互都通过中介者进行。
ConcreteColleague（具体同事类）：继承自同事类，能够通过中介者与其他对象进行交互。

3. 结构图

                +---------------------+
                |    Mediator         |
                +---------------------+
                | + notify()          |
                +---------------------+
                        ^
                        |
            +---------------------------+
            | ConcreteMediator           |
            +---------------------------+
            | + colleague1: Colleague1   |
            | + colleague2: Colleague2   |
            +---------------------------+
                        |
        +--------------------------+------------------+
        |                                              |
+---------------+                             +------------------+
| Colleague1    |                             | Colleague2       |
+---------------+                             +------------------+
| + setMediator()|                             | + setMediator()  |
| + action()     |                             | + action()       |
+---------------+                             +------------------+

4. 代码实现

4.1 中介者接口

首先，定义中介者接口，声明同事对象交互的方法。

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

4.2 具体中介者

然后，定义一个具体的中介者类，负责协调各个同事对象之间的交互。

// 具体中介者
public class ConcreteMediator implements Mediator {
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    // 设置同事对象
    public void setColleague1(Colleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void notify(Colleague colleague, String message) {
        if (colleague == colleague1) {
            // 如果是colleague1，通知colleague2
            colleague2.receive(message);
        } else {
            // 如果是colleague2，通知colleague1
            colleague1.receive(message);
        }
    }
}

4.3 同事类

接下来，定义一个同事类的接口，所有同事类都必须实现这个接口。

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

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

    // 设置中介者
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    // 接收消息
    public abstract void receive(String message);

    // 发送消息
    public abstract void send(String message);
}

4.4 具体同事类

然后，定义具体的同事类，负责执行具体的操作。

// 具体同事类1
public class Colleague1 extends Colleague {

    public Colleague1(Mediator mediator) {
        super(mediator);
    }

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

    @Override
    public void send(String message) {
        System.out.println("Colleague1 sends: " + message);
        mediator.notify(this, message);
    }
}

// 具体同事类2
public class Colleague2 extends Colleague {

    public Colleague2(Mediator mediator) {
        super(mediator);
    }

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

    @Override
    public void send(String message) {
        System.out.println("Colleague2 sends: " + message);
        mediator.notify(this, message);
    }
}

4.5 使用示例

最后，创建一个应用程序来使用中介者模式。

public class Main {
    public static void main(String[] args) {
        // 创建中介者对象
        ConcreteMediator mediator = new ConcreteMediator();

        // 创建具体同事对象
        Colleague1 colleague1 = new Colleague1(mediator);
        Colleague2 colleague2 = new Colleague2(mediator);

        // 设置同事对象
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        // 发送消息
        colleague1.send("Hello from Colleague1!");
        colleague2.send("Hello from Colleague2!");
    }
}

4.6 输出结果

Colleague1 sends: Hello from Colleague1!
Colleague2 received: Hello from Colleague1
Colleague2 sends: Hello from Colleague2!
Colleague1 received: Hello from Colleague2