中介者模式

# 中介者模式

# 一、中介者模式

原理：中介者模式是一种行为设计模式，能让你减少对象之间混乱无序的依赖关系。该模式会限制对象之间的直接交互，迫使它们通过一个中介者对象进行合作。
优缺点
1. 1 优点
- 降低对象之间的耦合性：对象之间不需要直接相互引用，它们通过中介者进行通信，从而降低了系统的耦合性。
- 简化对象间的通信：中介者模式将复杂的对象通信逻辑集中到一个中介者对象中，使各对象的逻辑更为简洁。
- 集中控制：中介者模式将交互逻辑集中管理，便于控制和修改，提高了系统的灵活性和可维护性。
- 增强代码的可读性：将复杂的交互逻辑隐藏在中介者对象中，使每个对象的职责更加单一和明确，从而提升代码的可读性。
1. 2 缺点
- 中介者对象可能变得过于复杂：随着系统规模的扩大，中介者对象可能会变得非常复杂，成为“上帝对象”。
- 增加系统的初始开发工作量：引入中介者模式需要额外设计和实现中介者对象，增加了初始开发的工作量。
- 潜在的性能问题：所有交互都通过中介者进行，可能会带来性能开销，特别是在高频交互场景中。
- 调试困难：交互逻辑集中在中介者对象中，一旦出现问题，可能增加调试难度。
适用场景
- 多对多关系：当系统中存在多个对象之间相互通信的复杂关系时，引入中介者可以简化这种关系。例如，一个图形界面应用程序中的多个 UI 组件之间的通信。
- 对象之间的紧耦合：当对象之间的交互导致彼此之间紧密耦合时，可以使用中介者模式将对象之间的交互逻辑集中管理，降低耦合度。这种情况经常出现在具有复杂交互的系统中。
- 减少子类生成：在一些情况下，如果对象之间的交互逻辑分散在多个子类中，可能会导致类的爆炸性增长。通过引入中介者模式，可以避免创建过多的子类。
- 事件驱动系统：在事件驱动的系统中，中介者模式可以用于处理各种事件的分发和处理。例如，在一个图形界面应用程序中，可以使用中介者模式来管理用户输入、UI 组件状态的变化等事件。
- 分布式系统：在分布式系统中，各个节点之间需要进行通信和协调。使用中介者模式可以简化节点之间的通信逻辑，提高系统的可扩展性和可维护性。

# 二、中介者模式基本代码

中介者接口

interface Mediator {
    void addColleague(Colleague colleague);
    void distributeMessage(Colleague sender, String message);
}

1
2
3
4

具体中介者类

class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues;

    public ConcreteMediator() {
        this.colleagues = new ArrayList<>();
    }

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void distributeMessage(Colleague sender, String message) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {  // 不将消息发送给发送者自己
                colleague.receiveMessage(message);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

抽象同事类

abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void sendMessage(String message);
    public abstract void receiveMessage(String message);
}

1
2
3
4
5
6
7
8
9
10
11

具体同事类

class ConcreteColleague extends Colleague {
    public ConcreteColleague(Mediator mediator) {
        super(mediator);
    }

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13

客户端

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

        // 创建同事对象并注册到中介者
        Colleague colleague1 = new ConcreteColleague(mediator);
        Colleague colleague2 = new ConcreteColleague(mediator);
        ((ConcreteMediator) mediator).addColleague(colleague1);
        ((ConcreteMediator) mediator).addColleague(colleague2);

        // 同事对象发送消息
        colleague1.sendMessage("Hello from colleague 1!");
        colleague2.sendMessage("Hello from colleague 2!");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 三、实现方式

找到一组当前紧密耦合，且提供其独立性能带来更大好处的类（例如更易于维护或更方便复用）。
声明中介者接口并描述中介者和各种组件之间所需的交流接口。在绝大多数情况下，一个接收组件通知的方法就足够了。

如果你希望在不同情景下复用组件类，那么该接口将非常重要。只要组件使用通用接口与其中介者合作，你就能将该组件与不同实现中的中介者进行连接。
实现具体中介者类。该类可从自行保存其下所有组件的引用中受益。
你可以更进一步，让中介者负责组件对象的创建和销毁。此后，中介者可能会与工厂 (opens new window)或外观 (opens new window)类似。
组件必须保存对于中介者对象的引用。该连接通常在组件的构造函数中建立，该函数会将中介者对象作为参数传递。
修改组件代码，使其可调用中介者的通知方法，而非其他组件的方法。然后将调用其他组件的代码抽取到中介者类中，并在中介者接收到该组件通知时执行这些代码。

编辑

#重学Java设计模式

← 适配器模式