19.中介者模式(行为型)

中介者模式(行为型)

原书连接设计模式(刘伟)

一、相关概述

1). 问题引入

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

---

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

---

如果在一个系统中对象之间存在多对多的相互关系，我们可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用。使用中介者类来协调多个类/对象之间的交互，以达到降低系统耦合度的目的。

2). 相关定义

1. 中介者模式：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

---

3). 角色介绍

1. Mediator（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通信。
2. ConcreteMediator（具体中介者）：它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用。
3. Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信。
4. ConcreteColleague（具体同事类）：它是抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法。

4). 中介者承担的职责

1. 中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。
2. 协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致的和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

5). 中介者模式典型代码

1. 中介者

import java.util.List;

/**
 * 典型的抽象中介者类
 */
abstract class Mediator {

    // 在抽象中介者中可以定义一个同事类的集合，用于存储同事对象并提供注册方法
    protected List<Colleague> colleagues;

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

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

/**
 * 具体中介者
 */
class ConcreteMediator extends Mediator {

    // 实现业务方法，封装同事之间的调用
    @Override
    public void operation() {
        // 通过中介者调用同事类的方法
        // 在具体中介者类中将调用同事类的方法，
        // 调用时可以增加一些自己的业务代码对调用进行控制。
    }
}

2. 同事类

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

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

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

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


/**
 * 具体同事类
 */
class ConcreteColleague extends Colleague {

    public ConcreteColleague(Mediator mediator) {
        super(mediator);
    }

    // 实现自身的方法
    @Override
    public void method1() {
        // 逻辑
    }
}

二、案例需求设计

1). 需求描述

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

---

现分析功能逻辑如下：

1. 当用户单击“增加”按钮、“删除”按钮、“修改”按钮或“查询”按钮时，界面左侧的“客户选择组合框”、“客户列表”以及界面中的文本框将产生响应。
2. 当用户通过“客户选择组合框”选中某个客户姓名时，“客户列表”和文本框将产生响应。
3. 当用户通过“客户列表”选中某个客户姓名时，“客户选择组合框”和文本框将产生响应。

2). 类图设计

---

3). 完整代码

1. 中介者

/**
 * 抽象中介者
 */
abstract class Mediator {

    // 接受同事类调用的方法
    public abstract void componentChanged(Component c);
}

/**
 * 具体中介者
 */
class ConcreteMediator extends Mediator {

    // 维持对各个对象的应用，由于子类可能会有特定的方法，所以这里用的子类的类声明
    public Button addButton;
    public List list;
    public ComoBox cb;
    public TextBox userNameTextBox;

    // 封装同事对象之间的交互
    @Override
    public void componentChanged(Component c) {
        // 单击按钮
        if (c == addButton) {
            System.out.println("--单击增加按钮--");
            list.update();
            cb.update();
            userNameTextBox.update();
        } else if (c == list) {
            // 从列表框选择客户
            System.out.println("--从列表框选择客户--");
            cb.select();
            userNameTextBox.setText();
        } else if (c == cb) {
            System.out.println("--从组合框选择客户--");
            cb.select();
            userNameTextBox.setText();
        }
    }
}

2. 同事类

/**
 * 抽象同事类: 抽象组件类
 */
abstract class Component {
    protected Mediator mediator;

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

    // 请求，转发调用
    public void changed() {
        mediator.componentChanged(this);
    }

    // 响应，自身被调用逻辑
    public abstract void update();

}

/**
 * 具体同事类：按钮类
 */
class Button extends Component {

    @Override
    public void update() {
        // 按钮不产生交互
    }
}

/**
 * 具体同事类：列表框类
 */
class List extends Component {

    @Override
    public void update() {
        System.out.println("列表增加一项：张无忌");
    }

    public void select() {
        System.out.println("列表框选中项：小龙女");
    }
}

/**
 * 具体同事类：组合框类
 */
class ComoBox extends Component {

    @Override
    public void update() {
        System.out.println("组合框增加一项：张无忌");
    }

    public void select() {
        System.out.println("组合框选中项：小龙女");
    }
}

/**
 * 具体同事类：文本框类
 */
class TextBox extends Component {

    @Override
    public void update() {
        System.out.println("客户信息增加成功后文本框清空");
    }

    public void setText() {
        System.out.println("文本框显示：小龙女");
    }
}

3. 客户端测试

/**
 * @author Liucheng
 * @since 2019-09-07
 */
public class Client {

    public static void main(String[] args) {

        // 定义中介者对象, 声明为具体类对象
        ConcreteMediator mediator = new ConcreteMediator();

        // 定义同事对象,这里得声明为子类类声明，可能每个子类有不同的业务
        Button addBT = new Button();
        List list = new List();
        ComoBox cb = new ComoBox();
        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();
        System.out.println("``````````````````````````````");
        list.changed();
    }
}

4). 系统拓展

要求在窗口的下端能够及时显示当前系统中客户信息的总数。修改之后的界面如图20-9所示：

---

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

2. 修改后的结构图

---

3. 代码

/**
 * 新增具体中介者类
 */
class Label extends Component {

    @Override
    public void update() {
        System.out.println("文本标签内容改变，客户信息总数加1.");
    }
}

// 新增具体中介者类
class SubConcreteMediator extends ConcreteMediator {
    // 增加对Label对象的引用
    public Label label;

    @Override
    public void componentChanged(Component c) {
        // 单击按钮
        if (c == addButton) {
            System.out.println("--单击增加按钮--");
            list.update();
            cb.update();
            userNameTextBox.update();

            // 文本标签更新
            label.update();
        } else if (c == list) {
            // 从列表框选择客户
            System.out.println("--从列表框选择客户--");
            cb.select();
            userNameTextBox.setText();
        } else if (c == cb) {
            System.out.println("--从组合框选择客户--");
            cb.select();
            userNameTextBox.setText();
        }
    }
}
/**
 * @author Liucheng
 * @since 2019-09-07
 */
public class Client {

    public static void main(String[] args) {

        // 定义中介者对象, 声明为具体类对象
        SubConcreteMediator mediator2 = new SubConcreteMediator();

        // 定义同事对象,这里得声明为子类类声明，可能每个子类有不同的业务
        Button addBT2 = new Button();
        List list2 = new List();
        ComoBox cb2 = new ComoBox();
        TextBox userNameTB2 = new TextBox();
        Label label = new Label();

        addBT2.setMediator(mediator2);
        list2.setMediator(mediator2);
        cb2.setMediator(mediator2);
        userNameTB2.setMediator(mediator2);
        label.setMediator(mediator2);

        mediator2.addButton = addBT2;
        mediator2.list = list2;
        mediator2.cb = cb2;
        mediator2.userNameTextBox = userNameTB2;
        mediator2.label = label;


        addBT2.changed();
        System.out.println("``````````````````````````````");
        list2.changed();
    }
}

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

三、总结

1). 使用建议

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

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

2). 优点

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

3). 缺点

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

4). 适用场景

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