散修程序员 - 详情

中介者模式（Mediator Pattern）是一种行为设计模式，它通过提供一个中介对象来封装一系列对象之间的交互。这种模式可以减少对象之间的直接依赖关系，促进对象之间的松耦合，有助于提高系统的可复用性和可维护性。

在中介者模式中，中介者对象通常包含多个组件对象，并且负责协调这些对象之间的交互。当一个组件对象的状态发生变化时，它可以通知中介者对象，然后由中介者对象来处理相应的更新或者通知其他相关的组件对象。

让我们通过一个简单的 Java 代码示例来说明中介者模式的实现：

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

// 具体中介者类
class ConcreteMediator implements Mediator {
    private ComponentA componentA;
    private ComponentB componentB;

    public ConcreteMediator(ComponentA componentA, ComponentB componentB) {
        this.componentA = componentA;
        this.componentB = componentB;
    }

    @Override
    public void notify(Component sender, String event) {
        if (sender == componentA) {
            System.out.println("Component A notified with event: " + event);
            // 在这里可以根据事件调整 Component A 和 Component B 的状态或行为
            componentB.handleEvent(event);
        } else if (sender == componentB) {
            System.out.println("Component B notified with event: " + event);
            // 在这里可以根据事件调整 Component A 和 Component B 的状态或行为
            componentA.handleEvent(event);
        }
    }
}

// 抽象组件类
abstract class Component {
    protected Mediator mediator;

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

    public abstract void sendEvent(String event);

    public abstract void handleEvent(String event);
}

// 具体组件类 A
class ComponentA extends Component {
    public ComponentA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendEvent(String event) {
        System.out.println("Component A sends event: " + event);
        mediator.notify(this, event);
    }

    @Override
    public void handleEvent(String event) {
        System.out.println("Component A handles event: " + event);
    }
}

// 具体组件类 B
class ComponentB extends Component {
    public ComponentB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendEvent(String event) {
        System.out.println("Component B sends event: " + event);
        mediator.notify(this, event);
    }

    @Override
    public void handleEvent(String event) {
        System.out.println("Component B handles event: " + event);
    }
}

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

        componentA.sendEvent("Event 1");
        componentB.sendEvent("Event 2");
    }
}

在这个示例中：

Mediator 是中介者接口，定义了一个 notify 方法用于组件之间的通信。
ConcreteMediator 是具体的中介者类，实现了 Mediator 接口，并负责协调 ComponentA 和 ComponentB 之间的交互。
Component 是抽象组件类，其中定义了一个 sendEvent 方法用于发送事件，并有一个 handleEvent 方法用于处理事件。
ComponentA 和 ComponentB 是具体的组件类，它们都继承自 Component，并实现了发送事件和处理事件的具体逻辑。

在 MediatorPatternExample 的 main 方法中，创建了一个具体的中介者对象 ConcreteMediator，并创建了两个具体的组件对象 ComponentA 和 ComponentB，它们通过中介者对象 ConcreteMediator 进行通信。当 ComponentA 或 ComponentB 发送事件时，中介者 ConcreteMediator 负责协调它们之间的交互，从而实现了解耦和的目的。

行为型模式-7.中介者模式（Mediator Pattern）