中介者模式

中介者模式（Mediator Pattern）是一种行为型设计模式，用于减少多个对象或类之间复杂的交互依赖。通过引入一个中介者对象，所有对象之间的通信不再直接进行，而是通过中介者来协调和管理，从而降低对象之间的耦合度。这使得系统更易于扩展和维护，因为对象之间的关系可以通过修改中介者来管理，而不必修改各个对象自身。

中介者模式的关键角色

1. 中介者（Mediator）： 定义组件之间通信的接口，负责管理和协调各个组件的交互。
2. 具体中介者（Concrete Mediator）： 实现中介者接口，包含所有组件的引用，并负责具体的组件之间的通信逻辑。
3. 组件（Component）： 组件是那些需要通信的对象，它们通过中介者来传递消息，而不与其他组件直接通信。

代码示例

以下是一个实现中介者模式的Java代码示例：

// 抽象组件类，所有组件都通过中介者进行通信
abstract class Component {
    protected Mediator mediator;

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

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
}

// 具体组件1
class Component1 extends Component {
    public Component1(Mediator mediator) {
        super(mediator);
    }

    public void doA() {
        System.out.println("组件1执行A操作。");
        mediator.notify(this, "A");
    }

    public void doC() {
        System.out.println("组件1执行C操作。");
    }
}

// 具体组件2
class Component2 extends Component {
    public Component2(Mediator mediator) {
        super(mediator);
    }

    public void doB() {
        System.out.println("组件2执行B操作。");
        mediator.notify(this, "B");
    }

    public void doC() {
        System.out.println("组件2执行C操作。");
    }
}

// 中介者接口，定义组件之间的通信方式
interface Mediator {
    void notify(Component sender, String event);
}

// 具体中介者类，负责管理各组件之间的交互
class ConcreteMediator implements Mediator {
    private Component1 component1;
    private Component2 component2;

    public void setComponent1(Component1 component1) {
        this.component1 = component1;
    }

    public void setComponent2(Component2 component2) {
        this.component2 = component2;
    }

    @Override
    public void notify(Component sender, String event) {
        if ("A".equals(event)) {
            System.out.print("中介者对A作出反应，并触发以下操作:");
            component2.doC();
        } else if ("B".equals(event)) {
            System.out.print("中介者对B作出反应，并触发以下操作:");
            component1.doC();
        }
    }
}

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

        Component1 component1 = new Component1(mediator);
        Component2 component2 = new Component2(mediator);

        mediator.setComponent1(component1);
        mediator.setComponent2(component2);

        System.out.println("客户端触发组件1的A操作：");
        component1.doA();

        System.out.println("\n客户端触发组件2的B操作：");
        component2.doB();
    }
}

运行结果

java复制代码客户端触发组件1的A操作：
组件1执行A操作。
中介者对A作出反应，并触发以下操作:组件2执行C操作。

客户端触发组件2的B操作：
组件2执行B操作。
中介者对B作出反应，并触发以下操作:组件1执行C操作。

代码解释

• Component1 和 Component2 是两个组件，它们并不直接相互通信，而是通过一个中介者（ConcreteMediator）来管理它们之间的交互。
• ConcreteMediator 持有组件的引用，并且负责在接收到事件时，决定哪一个组件应该执行相应的操作。
• 当 Component1 执行 doA() 方法时，它会通知中介者，中介者接收到消息后，会让 Component2 执行 doC() 操作。同理，当 Component2 执行 doB() 时，中介者会让 Component1 执行 doC()。

优点

1. 降低耦合：各组件不再相互依赖，而是通过中介者进行通信，降低了类之间的耦合度。
2. 提高可维护性：系统的变化集中在中介者中处理，组件的变化不会影响其他组件的实现，便于系统的扩展和维护。

缺点

1. 复杂性增加：随着组件数量的增加，中介者的逻辑可能会变得复杂，可能导致中介者本身变得难以维护。

适用场景

1. 系统中多个对象之间的复杂交互。
2. 需要集中控制交互逻辑时。
3. 对象间的通信难以维护或频繁变化时。