中介者模式

思考并回答以下问题：

• 中介者模式为什么是行为型模式？为什么是迪米特法则的一个典型应用？
• 中介者模式的核心在于中介者类的引入，中介者类维护一个同事类的列表。怎么理解？
• 像QQ群一样，QQ群维护了其他用户的QQ。怎么理解？

本章导学

对于对象之间存在复杂交互关系的系统，中介者模式提供了一种简化复杂交互的解决方案，它通过引入中介者，将原本对象之间的两两交互转化为每个对象与中介者之间的交互，中介者可以对对象之间的通信进行控制与协调，降低了原有系统的耦合度，使得系统更加灵活，也更易于扩展。

本章将学习中介者模式的定义与结构，理解为何以及如何引入中介者角色，学会编程实现中介者模式以及理解如何通过中介者模式来简化对象之间的复杂交互关系。

本章知识点

• 中介者模式的定义
• 中介者模式的结构
• 中介者模式的实现
• 中介者模式的应用
• 中介者模式的优缺点
• 中介者模式的适用环境

中介者模式概述

在QQ聊天中存在两种聊天方式：第一种是用户与用户直接聊天，第二种是通过QQ群聊天，如图1所示。如果使用图1（a）所示方式，一个用户要与其他用户聊天或发送文件，通常需要加其他用户为好友，用户与用户之间存在多对多的联系，这将导致系统中用户之间的关系非常复杂，一个用户如果将相同的信息或文件发送给其他所有用户，必须一个一个地发送，于是QQ群产生了，如图1（b）所示。如果使用QQ群，一个用户可以向多个用户发送相同的信息和文件而无须一一发送，只需将信息或文件发送到群中或上传为群共享文件即可，群的作用就是将发送者所发送的信息和文件转发给每一个接收者。通过引入群的机制，将极大地减少系统中用户之间的两两通信，用户与用户之间的联系可以通过群来实现。

图1 QQ聊天示意图

在软件系统中，某些类/对象之间的相互调用关系错综复杂，类似QQ用户之间的关系，此时，特别需要一个类似“QQ群”一样的中间类来协调这些类/对象之间的复杂关系，以降低系统的耦合度。中介者模式为此而“诞生”，它通过在系统中增加中介者对象来降低原有类/对象之间的复杂引用关系。

下面对中介者模式的模式动机做进一步说明：

如果在一个系统中对象之间的联系呈现为网状结构，如图2所示，对象之间存在着大量的多对多联系，将导致系统非常复杂，这些对象既会影响其他对象，也会被其他对象所影响，这些对象被称为同事对象，它们之间通过彼此的相互作用实现系统的行为。在网状结构中，几乎每个对象都需要与其他对象发生相互作用，而这种相互作用表现为一个对象与另外一个对象的直接耦合，这将导致一个过度耦合的系统。

图2 对象之间存在复杂关系的网状结构

中介者模式可以使对象之间的关系数量急剧减少，通过引入中介者对象，可以将系统的网状结构变成以中介者为中心的星形结构，如图3所示。在这个星形结构中，同事对象不再直接与另一个对象联系，它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入带来大量的修改工作。

图3 引入中介者对象的星形结构

如果在一个系统中对象之间存在着多对多的相互关系，可以将对象之间的一些交互行为从各个对象中分离出来，集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。

中介者模式的定义如下：

定义一个对象来封装一系列对象的交互。中介者模式使各对象之间不需要显式地相互引用，从而使其耦合松散，而且让你可以独立地改变它们之间的交互。

中介者模式又称为调停者模式，它是一种对象行为型模式。在中介者模式中，通过引入中介者来简化对象之间的复杂交互，中介者模式是迪米特法则的一个典型应用。

中介者模式的结构与实现

中介者模式的结构

在中介者模式中，引入了用于协调其他对象/类之间相互调用的中介者类，为了让系统具有更好的灵活性和可扩展性，通常还提供了抽象中介者，其结构如图4所示。

图4 中介者模式结构图

由图4可知，中介者模式包含以下4个角色。

(1)Mediator（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通信。

(2)ConcreteMediator（具体中介者）：它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，维持了对各个同事对象的引用。

(3)Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用与中介者通信。

(4)ConcreteColleague（具体同事类）：它是抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法。

中介者模式的实现

中介者模式的核心在于中介者类的引入，在中介者模式中，中介者类承担了两个方面的职责。

(1)中转作用（结构性）：通过中介者提供的中转作用，各个同事对象不再需要显式地引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。

(2)协调作用（行为性）：中介者可以更进一步对同事之间的关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

在中介者模式中，典型的抽象中介者类代码如下：

using System.Collections.Generic;

abstract class Mediator
{
    // 用于存储同事对象
    protected List<Colleague> colleague = new List<Colleague>();

    // 注册方法，用于增加同事对象
    public void Register(Colleague colleague)
    {
        colleague.Add(colleague);
    }

    // 声明抽象的业务方法
    public abstract void Operation();
}

在抽象中介者中可以定义一个同事类的集合，用于存储同事对象并提供注册方法，同时声明了具体中介者类所具有的方法。在具体中介者类中将实现这些抽象方法，典型的具体中介者类代码如下：

class ConcreteMediator : Mediator
{
    // 实现业务方法，封装同事之间的调用
    public override void Operation()
    {
        ...
        ((Colleague)(colleagues[0])).Method1(); // 通过中介者调用同事类的方法
        ..
    }
}

在具体中介者类中将调用同事类的方法，调用时可以增加一些自己的业务代码对调用进行控制。

在抽象同事类中维持了一个抽象中介者的引用，用于调用中介者的方法。典型的抽象同事类代码如下：

abstract class Colleague
{
    // 维持一个抽象中介者的引用
    protected Mediator mediator;

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

    public abstract void Method1(); // 声明自身方法，处理自己的行为

    // 定义依赖方法，与中介者进行通信
    public void Method2()
    {
        mediator.Operation();
    }
}

在抽象同事类中声明了同事类的抽象方法，在具体同事类中将实现这些方法。典型的具体同事类代码如下：

class ConcreteColleague : Colleague
{
    public ConcreteColleague(Mediator mediator) : base(mediator)
    {

    }

    // 实现自身方法
    public override void Method1()
    {
        ...
    }
}

在具体同事类ConcreteColleague中实现了在抽象同事类中声明的方法，其中，方法Method1()是同事类的自身方法（Self-Method），用于处理自己的行为，而方法Method2()是依赖方法（Depend-Method），用于调用在中介者中定义的方法，依赖中介者完成相应的行为，例如调用另一个同事类的相关方法。

中介者模式的应用实例

下面通过一个应用实例来进一步学习和理解中介者模式。

1.实例说明

某软件公司要开发一套CRM系统，其中包含一个客户信息管理模块，所设计的“客户信息管理窗口”界面效果图如图5所示。

图5 “客户信息管理窗口”界面效果图

通过分析发现，在图5中，界面组件之间存在着较为复杂的交互关系：如果删除一个客户，将从客户列表（List）中删掉对应的项，客户选择组合框（ComboBox）中的客户名称也将减少一个；如果增加一个客户信息，则客户列表中将增加一个客户，且组合框中也将增加一项。

为了更好地处理界面组件之间的交互，现使用中介者模式设计该系统。

2.实例类图

为了协调界面组件对象之间的复杂交互关系，可引入一个中介者类，其结构如图6所示。

图6 引入中介者类的“客户信息管理窗口”结构示意图

图6只是一个结构示意图，在具体实现时，为了确保系统具有更好的灵活性和可扩展性，需要定义抽象中介者和抽象组件类，其中，抽象组件类是所有具体组件类的公共父类，完整类图如图7所示。

图7 “客户信息管理窗口”结构图

在图7中，Component充当抽象同事类，Button、List、ComboBox和TextBox充当具体同事类，Mediator充当抽象中介者类，ConcreteMediator充当具体中介者类，ConcreteMediator维持了对具体同事类的引用，为了简化ConcreteMediator类的代码，在其中只定义了一个Button对象和一个TextBox对象。

3.实例代码

(1)Mediator：抽象中介者类。

namespace MediatorSample
{
    abstract class Mediator
    {
        public abstract void ComponentChanged(Component c);
    }
}

(2)ConcreteMediator：具体中介者类。

using System;

namespace MediatorSample
{
    class ConcreteMediator : Mediator
    {
        // 维持对各个同事对象的引用
        public Button addButton;
        public List list;
        public TextBox userNameTextBox;
        public ComboBox cb;

        // 封装同事对象之间的交互
        public override void ComponentChanged(Component c) 
        {
            // 单击按钮
            if (c == addButton) 
            {
                Console.WriteLine("--单击增加按钮--");
                list.Update();
                cb.Update();
                userNameTextBox.Update();
            }
            // 从列表框选择客户
            else if (c == list) 
            {
                Console.WriteLine("--从列表框选择客户--");
                cb.Select();
                userNameTextBox.SetText();
            }
            // 从组合框选择客户
            else if (c == cb) 
            {
                Console.WriteLine("--从组合框选择客户--");
                cb.Select();
                userNameTextBox.SetText();
            }
        }
    }
}

(3)Component：抽象组件类，充当抽象同事类。

namespace MediatorSample
{
    abstract class Component
    {
        protected Mediator mediator;

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

        // 转发调用
        public void Changed()
        {
            mediator.ComponentChanged(this);
        }

        public abstract void Update();
    }
}

(4)Button：按钮类，充当具体同事类。

namespace MediatorSample
{
    class Button : Component 
    {
        public override void Update() 
        {
            // 按钮不产生响应
        }
    }
}

(5)List：列表框类，充当具体同事类。

using System;

namespace MediatorSample
{
    class List : Component
    {
        public override void Update() 
        {
            Console.WriteLine("列表框增加一项：张无忌。");
        }

        public void Select() 
        {
            Console.WriteLine("列表框选中项：小龙女。");
        }
    }
}

(6)ComboBox：组合框类，充当具体同事类。

using System;

namespace MediatorSample
{
    class ComboBox : Component 
    {
        public override void Update() 
        {
            Console.WriteLine("组合框增加一项：张无忌。");
        }
    
        public void Select() 
        {
            Console.WriteLine("组合框选中项：小龙女。");
        }
    }
}

(7)TextBox：文本框类，充当具体同事类。

using System;

namespace MediatorSample
{
    class TextBox : Component 
    {
        public override void Update() 
        {
            Console.WriteLine("客户信息增加成功后文本框清空。");
        }
    
        public void SetText() 
        {
            Console.WriteLine("文本框显示：小龙女。");
        }
    }
}

(8)Program：客户端测试类。

using System;

namespace MediatorSample
{
    class Program
    {
        static void Main(string[] args)
        {
            
            // 定义中介者对象
            ConcreteMediator mediator;
            mediator = new ConcreteMediator();
        
            // 定义同事对象
            Button addBT = new Button();
            List list = new List();
            ComboBox cb = new ComboBox();
            TextBox userNameTB = new TextBox();

            addBT.SetMediator(mediator);
            list.SetMediator(mediator);
            cb.SetMediator(mediator);
            userNameTB.SetMediator(mediator);

            mediator.addButton = addBT;
            mediator.list = list;
            mediator.cb = cb;
            mediator.userNameTextBox = userNameTB;
        
            addBT.Changed();
            Console.WriteLine("-----------------------------");
            list.Changed();
           
            Console.Read();
        }
    }
}

4.结果及分析

编译并运行程序，输出结果如下：

--单击增加按钮--  
列表框增加一项：张无忌。  
组合框增加一项：张无忌。  
客户信息增加成功后文本框清空。
-----------------------------
--从列表框选择客户--  
组合框选中项：小龙女。  
文本框显示：小龙女。

在引入中介者后，同事之间的复杂交互由中介者间接实现，当某个组件类的Changed()方法被调用时，中介者的ComponentChanged()方法将被调用，在中介者的ComponentChanged()方法中再逐个调用与该组件有交互的其他组件的相关方法。如果某个组件类需要与新的组件进行交互，无须修改已有组件类的源代码，只需修改中介者或者对现有中介者进行扩展即可，系统具有更好的灵活性和可扩展性。

扩展中介者与同事类

本节将对上一节中的“客户信息管理窗口”进行改进，在窗口的下端能够及时显示当前系统中客户信息的总数，如图8所示。

图8 修改之后的“客户信息管理窗口”界面图

从图8中不难发现，可以通过增加一个文本标签(Label)来显示客户信息总数，而且当用户单击“增加”按钮或者“删除”按钮时，将改变文本标签的内容。

由于使用了中介者模式，在原有系统中增加新的组件（即新的同事类）将变得很容易，至少有以下两种解决方案。

方案(1)：增加一个界面组件类Label，修改原有具体中介者类ConcreteMediator，增加一个对Label对象的引用，然后修改ComponentChanged()方法中其他相关组件对象的业务处理代码，原有组件类无须任何修改，客户端代码需针对新增组件Label进行适当修改。

方案(2)：与方案(1)类似，首先增加一个Label类，但不修改原有具体中介者类ConcreteMediator的代码，而是增加一个ConcreteMediator的子类SubConcreteMediator来实现对Label对象的引用，然后在新增的中介者类SubConcreteMediator中通过覆盖ComponentChanged()方法实现所有组件(包括新增组件Label)之间的交互，同样，原有组件类无须做任何修改，客户端代码需少许修改。

引入Label之后的“客户信息管理窗口”类结构示意图如图9所示。

图9 增加Label组件类后的“客户信息管理窗口”结构示意图

由于方案(2)无须修改ConcreteMediator类，更符合开闭原则，因此选择方案(2)对新增Label类进行处理，对应的完整类图如图10所示。

图10 修改之后的“客户信息管理窗口”结构图

在图10中新增了具体同事类Label和具体中介者类SubConcreteMediator，代码如下：

Label.cs 文本标签类，充当具体同事类

using System;

namespace MediatorSample
{
    class Label : Component
    {
        public override void Update() 
        {
            Console.WriteLine("文本标签内容改变，客户信息总数加1。");
        }
    }
}

SubConcreteMediator.cs 新增具体中介者类

using System;

namespace MediatorSample
{
    class SubConcreteMediator : ConcreteMediator
    {
        // 增加对Label对象的引用
        public Label label;

        public override void ComponentChanged(Component c) 
        {
            // 单击按钮
            if (c == addButton) 
            {
                Console.WriteLine("--单击增加按钮--");
                list.Update();
                cb.Update();
                userNameTextBox.Update();
                label.Update(); // 文本标签更新
            }
            // 从列表框选择客户
            else if (c == list) 
            {
                Console.WriteLine("--从列表框选择客户--");
                cb.Select();
                userNameTextBox.SetText();
            }
            // 从组合框选择客户
            else if (c == cb) 
            {
                Console.WriteLine("--从组合框选择客户--");
                cb.Select();
                userNameTextBox.SetText();
            }
        }
    }
}

修改客户端测试代码如下：

using System;

namespace MediatorSample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 用新增具体中介者定义中介者对象
            SubConcreteMediator mediator;
            mediator = new SubConcreteMediator();
        
            Button addBT = new Button();
            List list = new List();
            ComboBox cb = new ComboBox();
            TextBox userNameTB = new TextBox();
            Label label = new Label();

            addBT.SetMediator(mediator);
            list.SetMediator(mediator);
            cb.SetMediator(mediator);
            userNameTB.SetMediator(mediator);
            label.SetMediator(mediator);
        
            mediator.addButton = addBT;
            mediator.list = list;
            mediator.cb = cb;
            mediator.userNameTextBox = userNameTB;
            mediator.label = label;
            
            addBT.Changed();
            Console.WriteLine("-----------------------------");
            list.Changed();

            Console.Read();
        }
    }
}

编译并运行程序，输出结果如下：

--单击增加按钮--  
列表框增加一项：张无忌。  
组合框增加一项：张无忌。  
客户信息增加成功后文本框清空。
文本标签内容改变，客户信息总数加1。
-----------------------------
--从列表框选择客户--  
组合框选中项：小龙女。  
文本框显示：小龙女。

由于在本实例中不同的组件类(即不同的同事类)拥有的方法并不完全相同，因此，中介者类没有针对抽象同事类编程，导致在具体中介者类中需要维持对具体同事类的引用，客户端代码无法完全透明地对待所有同事类和中介者类。在某些情况下，如果设计得当，可以在客户端透明地对同事类和中介者类编程，这样系统将具有更好的灵活性和可扩展性。

在中介者模式的实际使用过程中，如果需要引入新的具体同事类，只需继承抽象同事类并实现其中的方法即可，由于具体同事类之间并无直接的引用关系，因此原有所有同事类无须进行任何修改，它们与新增同事对象之间的交互可以通过修改或者增加具体中介者类来实现；如果需要在原有系统中增加新的具体中介者类，只需继承抽象中介者类（或已有的具体中介者类）并覆盖其中定义的方法即可，在新的具体中介者中可以通过不同的方式来处理对象之间的交互，也可以增加对新增同事的引用和调用。在客户端中只需修改少许代码（如果引入配置文件可以不用修改任何代码）就可以实现中介者类的更换。

中介者模式的优缺点与适用环境

中介者模式将一个网状的系统结构变成一个以中介者对象为中心的星形结构，在这个星形结构中，使用中介者对象与其他对象的一对多关系来取代原有对象之间的多对多关系。中介者模式在事件驱动类软件中的应用较为广泛，特别是基于GUI(Graphical User Interface，图形用户界面）的应用软件，此外，在类与类之间存在错综复杂的关联关系的系统中，中介者模式也得到了较好的应用。

中介者模式的优点

中介者模式的主要优点如下：

• (1)中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星形结构。
• (2)可将各同事对象解耦，中介者模式有利于各同事之间的松耦合，可以独立地改变和复用每一个同事和中介者，增加新的中介者类和新的同事类都比较方便，更好地符合开闭原则。
• (3)可以减少子类的生成，中介者模式将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使得各个同事类可被重用，无须直接对同事类进行扩展。

中介者模式的缺点

中介者模式的主要缺点如下：

在具体中介者类中包含了大量的同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。

中介者模式的适用环境

在以下情况下可以考虑使用中介者模式：

• (1)系统中对象之间存在着复杂的引用关系，系统结构混乱且难以理解。
• (2)一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
• (3)用户想通过一个中间类来封装多个类中的行为，又不想生成太多的子类，此时可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的具体中介者类。

本章小结

(1)中介者模式通过定义一个对象来封装一系列对象的交互。中介者模式使各对象之间不需要显式地相互引用，从而使其耦合松散，而且让你可以独立地改变它们之间的交互。

(2)中介者模式包含抽象中介者、具体中介者、抽象同事类和具体同事类4个角色。其中，抽象中介者定义一个接口，该接口用于和各同事对象之间进行通信；具体中介者是抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用；抽象同事类定义各个同事类公有的方法，并声明了一些抽象方法供子类实现；具体同事类是抽象同事类的子类，每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者间接完成与其他同事类的通信。

(3)中介者模式的主要优点包括它简化了对象之间的交互，可将各同事对象解耦，还可以减少子类的生成。其主要缺点是在具体中介者类中包含了大量的同事之间的交互细节可能会导致具体中介者类非常复杂，使得系统难以维护。

(4)中介者模式适用的环境：系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解；一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象；用户想通过一个中间类来封装多个类中的行为，又不想生成太多的子类。

(5)在中介者模式中，中介者类承担了中转和协调双重职责。