协调多个对象之间的交互——中介者模式（四）

20.4 中介者与同事类的扩展

Sunny软件公司CRM系统的客户对“客户信息管理窗口”提出了一个修改意见：要求在窗口的下端能够及时显示当前系统中客户信息的总数。修改之后的界面如图20-9所示：

协调多个对象之间的交互——中介者模式（四） - 图1

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

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

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

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

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

引入Label之后“客户信息管理窗口”类结构示意图如图20-10所示：

协调多个对象之间的交互——中介者模式（四） - 图2

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

由于【解决方案二】无须修改ConcreteMediator类，更符合“开闭原则”，因此我们选择该解决方案来对新增Label类进行处理，对应的完整类图如图20-11所示：

协调多个对象之间的交互——中介者模式（四） - 图3

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

在图20-11中，新增了具体同事类Label和具体中介者类SubConcreteMediator，代码如下所示：

  1. //文本标签类：具体同事类  
  2. class Label extends Component {  
  3.     public void update() {  
  4.         System.out.println("文本标签内容改变，客户信息总数加1。");  
  5.     }  
  6. }  
  8. //新增具体中介者类  
  9. class SubConcreteMediator extends ConcreteMediator {  
  10.     //增加对Label对象的引用  
  11.     public Label label;  
  13.     public void componentChanged(Component c) {  
  14.         //单击按钮  
  15. if(c == addButton) {  
  16.             System.out.println("--单击增加按钮--");  
  17.             list.update();  
  18.             cb.update();  
  19.             userNameTextBox.update();  
  20.             label.update(); //文本标签更新  
  21.         }  
  22.         //从列表框选择客户  
  23.         else if(c == list) {  
  24.             System.out.println("--从列表框选择客户--");  
  25.             cb.select();  
  26.             userNameTextBox.setText();  
  27.         }  
  28.         //从组合框选择客户  
  29.         else if(c == cb) {  
  30.             System.out.println("--从组合框选择客户--");  
  31.             cb.select();  
  32.             userNameTextBox.setText();  
  33.         }  
  34.     }  
  35. }

修改客户端测试代码：

  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         //用新增具体中介者定义中介者对象  
  4.         SubConcreteMediator mediator;  
  5.         mediator = new SubConcreteMediator();  
  7.         Button addBT = new Button();  
  8.         List list = new List();  
  9.         ComboBox cb = new ComboBox();  
  10.         TextBox userNameTB = new TextBox();  
  11.         Label label = new Label();  
  13.         addBT.setMediator(mediator);  
  14.         list.setMediator(mediator);  
  15.         cb.setMediator(mediator);  
  16.         userNameTB.setMediator(mediator);  
  17.         label.setMediator(mediator);  
  19.         mediator.addButton = addBT;  
  20.         mediator.list = list;  
  21.         mediator.cb = cb;  
  22.         mediator.userNameTextBox = userNameTB;  
  23.         mediator.label = label;  
  25.         addBT.changed();  
  26.         System.out.println("-----------------------------");  
  27.         list.changed();  
  28.     }  
  29. }

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

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

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

思考

如果不使用中介者模式，按照图20-3所示设计方案，增加新组件时原有系统该如何修改？

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