设计模式 <行为型> | 中介者模式

中介模式(Mediator Pattern)

中介模式定义了一个单独的中介对象，来封装一组对象之间的交互。将这组对象之间的交互委派给与中介对象交互，来避免对象之间的直接交互。

结构图：

角色：

1. 抽象中介者(Mediator)：接口声明了与组件交流的方法，但通常仅包括一个通知方法。
2. 具体中介者(Concrete Mediator)：封装了多种组件间的关系。 具体中介者通常会保存所有组件的引用并对其进行管理。
3. 抽象组件(Component)：声明所有组件公共方法和属性。
4. 具体组件(Concrete Colleague)：包含业务逻辑的类，每个组件都有一个指向中介者的引用的接口类型，组件不知道中介者实际所属的类， 因此可通过将其连接到不同的中介者以使其能在其他程序中复用。

适用场景：

1. 对象和其他对象紧密耦合度过高时。

优点：

1. 通过增加中介者可以有效的解决类耦合度过高的问题。

缺点：

1. 中介类过于臃肿，最终可能会演化成上帝类。

代码(C#)

/// <summary>
/// 抽象中介者
/// </summary>
public interface IMediator
{
    void Notify(BaseComponent sender, string ev);
}


/// <summary>
/// 具体中介
/// </summary>
public class ConcreteMediator : IMediator
{
    private Component1 _component1;

    private Component2 _component2;

    public ConcreteMediator(Component1 component1, Component2 component2)
    {
        _component2 = component2;
        _component1 = component1;

        // 指定中介
        _component1.SetMediator(this);
        _component2.SetMediator(this);
    }

    public void Notify(BaseComponent sender, string ev)
    {
        if (ev == "A")
        {
            _component2.DoC();
        }

        if (ev == "D")
        {
            _component1.DoB();
            _component2.DoC();
        }
    }
}

/// <summary>
/// 基础组件
/// </summary>
public class BaseComponent
{
    protected IMediator? _mediator;

    public BaseComponent(IMediator? mediator = null)
    {
        _mediator = mediator;
    }

    public void SetMediator(IMediator? mediator)
    {
        _mediator = mediator;
    }
}

/// <summary>
/// 具体组件
/// </summary>
public class Component1 : BaseComponent
{
    public void DoA()
    {
        Console.WriteLine("Component 1 does A.");

        _mediator?.Notify(this, "A");
    }

    public void DoB()
    {
        Console.WriteLine("Component 1 does B.");
        _mediator?.Notify(this, "B");
    }
}

/// <summary>
/// 具体组件
/// </summary>
public class Component2 : BaseComponent
{
    public void DoC()
    {
        Console.WriteLine("Component 2 does C.");

        _mediator?.Notify(this, "C");
    }

    public void DoD()
    {
        Console.WriteLine("Component 2 does D.");

        _mediator?.Notify(this, "D");
    }
}

Component1 component1 = new Component1();
Component2 component2 = new Component2();
IMediator mediator = new ConcreteMediator(component1, component2);

Console.WriteLine("触发A操作");
component1.DoA();

Console.WriteLine();

Console.WriteLine("触发D操作");
component2.DoD();

最后

中介模式的设计思想跟中间层很像，通过引入中介这个中间层，将一组对象之间的交互关系（或者依赖关系）从多对多（网状关系）转换为一对多（星状关系）。原来一个对象要跟 n 个对象交互，现在只需要跟一个中介对象交互，从而最小化对象之间的交互关系，降低了代码的复杂度，提高了代码的可读性和可维护性。