设计模式-行为型-中介者模式(Mediator)

参考文献

中介者模式

定义一个对象来封装一组对象如何交互。中介器通过防止对象显式地相互引用来促进松散耦合，并且它允许您独立地改变它们的交互。
中介器通过强制类的通信流通过中介对象来解耦一组类。

组件

Mediator- 定义与 Colleague 对象通信的接口。
ConcreteMediator - 了解Colleague 类并保留对Colleague 对象的引用。
- 实现Colleague类之间的通信和消息传递
Colleague classes- 保留对其 Mediator 对象的引用
- 每当它本来可以与其他Colleague进行通信时，就与调解器进行通信。

实现方式

确定需要解耦的一组当前紧密耦合的类，这些类之间存在复杂的交互关系。
声明一个中介者接口，并在该接口中描述中介者和各个组件之间所需的交流接口。通常情况下，一个接收组件通知的方法就足够了。
实现具体的中介者类，该类可以从自身保存的所有组件的引用中受益。中介者类负责协调各个组件之间的交互，可以根据具体需求在中介者类中定义一些通用行为。
让组件保存对中介者对象的引用，并在组件的构造函数中建立与中介者的连接。这样组件就可以通过调用中介者的方法来通知其他组件或执行其他操作。
修改组件的代码，使其调用中介者的通知方法，而不是直接调用其他组件的方法。将原本调用其他组件的代码抽取到中介者类中，在中介者接收到组件通知时执行这些代码。

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

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

    public void setComponentA(ComponentA componentA) {
        this.componentA = componentA;
    }

    public void setComponentB(ComponentB componentB) {
        this.componentB = componentB;
    }

    @Override
    public void notify(Component sender, String message) {
        if (sender == componentA) {
            System.out.println("Component A notified: " + message);
            // 执行其他逻辑
            componentB.doSomething();
        } else if (sender == componentB) {
            System.out.println("Component B notified: " + message);
            // 执行其他逻辑
            componentA.doSomething();
        }
    }
}

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

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

    public abstract void notify(String message);
}

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

    @Override
    public void notify(String message) {
        mediator.notify(this, message);
    }

    public void doSomething() {
        System.out.println("Component A is doing something.");
    }
}

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

    @Override
    public void notify(String message) {
        mediator.notify(this, message);
    }

    public void doSomething() {
        System.out.println("Component B is doing something.");
    }
}

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

        ComponentA componentA = new ComponentA(mediator);
        ComponentB componentB = new ComponentB(mediator);

        mediator.setComponentA(componentA);
        mediator.setComponentB(componentB);

        componentA.notify("Hello, Component B!");
        componentB.notify("Hi, Component A!");
    }
}

使用场景

当一些对象和其他对象紧密耦合以致难以对其进行修改时，可使用中介者模式
- 中介者模式可以将复杂的交互逻辑集中到一个中介者对象中，使得各个对象不再直接依赖彼此，而是通过中介者进行通信和协调。这样一来，如果需要修改或扩展交互逻辑，只需修改中介者对象而不影响其他对象。
当组件因过于依赖其他组件而无法在不同应用中复用时，可使用中介者模式
- 中介者模式可以帮助我们解决组件之间的紧耦合问题。通过引入一个中介者对象，各个组件不再直接依赖其他组件，而是通过中介者进行交互。这样可以提高组件的独立性和复用性，使得它们可以在不同的应用场景中进行复用。
如果为了能在不同情景下复用一些基本行为，导致你需要被迫创建大量组件子类时，可使用中介者模式
- 当需要在多个对象之间复用某些基本行为时，如果直接在每个对象中实现这些行为可能需要创建大量的子类。而使用中介者模式，可以将这些基本行为抽取到中介者对象中，各个对象通过调用中介者来实现这些行为，从而避免了大量的子类创建。