5.行为模式-中介者模式 中介的形象

中介者模式（Mediator Pattern）

定义

中介者模式是一种行为型设计模式，定义了一个对象来封装一组对象之间的交互。通过引入一个中介者对象，多个对象不再直接相互引用，而是通过中介者来进行交互，从而降低对象之间的耦合性。

核心思想

中介者模式的核心思想是将对象之间的复杂交互逻辑集中管理，将对象之间的直接依赖转换为对中介者的依赖。这样做不仅简化了对象之间的通信，还增强了系统的灵活性和可维护性。

组成部分

1. Mediator（中介者接口）：定义了一个接口用于对象间的通信，通常包括通知和协调的职责。
2. ConcreteMediator（具体中介者）：实现中介者接口，负责管理和协调相关对象的交互。
3. Colleague（同事类接口）：定义了与中介者进行交互的接口，通常包括接收中介者通知的方法。
4. ConcreteColleague（具体同事类）：实现同事类接口，通过中介者与其他同事类进行通信。

类图示例

    +-------------------+          +-------------------+          +-------------------+
   |      Mediator      |<-------->|   Colleague       |          |   ConcreteColleague|
   +-------------------+          +-------------------+          +-------------------+
   | + notify()         |          | + setMediator()   |          |                   |
   | + send()           |          |                   |          +-------------------+
   +-------------------+          +-------------------+          

             ^
             |
    +-------------------+
    |ConcreteMediator    |
    +-------------------+
    | + notify()         |
    | + send()           |
    +-------------------+

类图解释

• Mediator：中介者接口，定义了协调各个同事类的方法，如 notify() 和 send()。
• ConcreteMediator：具体中介者类，实现中介者接口，管理具体的同事类之间的交互。
• Colleague：同事类接口，定义了与中介者进行交互的方法，通常包括接收中介者通知的方法。
• ConcreteColleague：具体同事类，通过中介者与其他同事类进行通信。

代码示例

以下是一个中介者模式的示例，演示了如何通过中介者协调多个对象之间的通信：

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

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

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

    public abstract void doAction();
}

// 具体同事类1
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void doAction() {
        System.out.println("ConcreteColleague1 does an action.");
        mediator.notify(this, "Action1");
    }

    public void reactOnAction() {
        System.out.println("ConcreteColleague1 reacts on action.");
    }
}

// 具体同事类2
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void doAction() {
        System.out.println("ConcreteColleague2 does an action.");
        mediator.notify(this, "Action2");
    }

    public void reactOnAction() {
        System.out.println("ConcreteColleague2 reacts on action.");
    }
}

// 具体中介者类
class ConcreteMediator implements Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

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

    @Override
    public void notify(Colleague colleague, String event) {
        if (colleague instanceof ConcreteColleague1) {
            colleague2.reactOnAction();
        } else if (colleague instanceof ConcreteColleague2) {
            colleague1.reactOnAction();
        }
    }
}

// 客户端代码
public class MediatorPatternExample {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.doAction();
        colleague2.doAction();
    }
}

代码解释

1. Mediator 接口：定义了 notify() 方法，用于接收同事类的事件并通知其他同事类。
2. ConcreteMediator 类：实现了中介者接口，负责协调 ConcreteColleague1 和 ConcreteColleague2 之间的交互。
3. Colleague 类：抽象同事类，持有中介者的引用，通过中介者与其他同事类进行通信。
4. ConcreteColleague1 和 ConcreteColleague2 类：具体同事类，执行某些操作，并通过中介者与对方进行通信。
5. MediatorPatternExample 类：客户端代码，通过中介者协调两个具体同事类之间的交互。

优点

1. 减少对象之间的直接依赖：中介者模式将对象之间的交互集中在一个中介者对象中，避免了多个对象之间直接依赖，使得系统更加松耦合。
2. 集中管理交互逻辑：中介者模式将复杂的交互逻辑集中在中介者中，便于管理和修改。
3. 提高系统灵活性：通过引入中介者，系统可以更容易地增加或修改同事类，而不需要修改其他同事类的代码。

缺点

1. 中介者可能变得复杂：随着系统的扩展，中介者可能需要处理越来越多的交互逻辑，从而变得复杂且难以维护。
2. 性能开销：引入中介者可能会增加系统的性能开销，特别是在频繁交互的场景中。

适用场景

1. 多个对象之间有复杂的交互：如果多个对象之间存在复杂的交互逻辑，可以引入中介者模式，将这些交互集中管理。
2. 对象之间的交互频繁变化：如果对象之间的交互逻辑经常变化，使用中介者模式可以简化代码的修改。
3. 松耦合的系统设计：中介者模式适用于需要保持系统松耦合的场景，尤其是多个对象相互依赖时。

总结

中介者模式通过引入一个中介者对象，减少了对象之间的直接依赖，将复杂的交互逻辑集中在中介者中。它使系统更加灵活和可维护，适用于多个对象之间存在复杂交互的场景。在实际开发中，中介者模式被广泛应用于 GUI 应用程序、网络协议设计以及消息传递系统中。

Tags：abstract class