在现实生活中，常常会出现好多对象之间存在复杂的交互关系，这种交互关系常常是“网状结构”，它要求每个对象都必须知道它需要交互的对象。例如，每个人必须记住他（她）所有朋友的电话；而且，朋友中如果有人的电话修改了，他（她）必须让其他所有的朋友一起修改，这叫作“牵一发而动全身”，非常复杂。如果把这种“网状结构”改为“星形结构”的话，将大大降低它们之间的“耦合性”，这时只要找一个“中介者”就可以了。如前面所说的“每个人必须记住所有朋友电话”的问题，只要在网上建立一个每个朋友都可以访问的“通信录”就解决了。这样的例子还有很多，例如，你刚刚参加工作想租房，可以找“房屋中介”；或者，自己刚刚到一个陌生城市找工作，可以找“人才交流中心”帮忙。在软件的开发过程中，这样的例子也很多，例如，在 MVC 框架中，控制器（C）就是模型（M）和视图（V）的中介者；还有大家常用的 QQ 聊天程序的“中介者”是 QQ 服务器。所有这些，都可以采用“中介者模式”来实现，它将大大降低对象之间的耦合性，提高系统的灵活性。

模式的定义与特点

中介者（Mediator）模式的定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。中介者模式是一种对象行为型模式，其主要优点如下。

  1. 类之间各司其职，符合迪米特法则。
  2. 降低了对象之间的耦合性，使得对象易于独立地被复用。
  3. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

其主要缺点是：中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

模式的结构与实现

中介者模式实现的关键是找出“中介者”，下面对它的结构和实现进行分析。

1. 模式的结构

中介者模式包含以下主要角色。

  1. 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
  2. 具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
  3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
  4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

中介者模式的结构图如图 1 所示。中介者模式(Mediator) - 图1
图1 中介者模式的结构图

2. 模式的实现

中介者模式的实现代码如下：

  1. package net.biancheng.c.mediator;
  3. import java.util.*;
  5. public class MediatorPattern {
  6.     public static void main(String[] args) {
  7.         Mediator md = new ConcreteMediator();
  8.         Colleague c1, c2;
  9.         c1 = new ConcreteColleague1();
  10.         c2 = new ConcreteColleague2();
  11.         md.register(c1);
  12.         md.register(c2);
  13.         c1.send();
  14.         System.out.println("-------------");
  15.         c2.send();
  16.     }
  17. }
  19. //抽象中介者
  20. abstract class Mediator {
  21.     public abstract void register(Colleague colleague);
  23.     public abstract void relay(Colleague cl); //转发
  24. }
  26. //具体中介者
  27. class ConcreteMediator extends Mediator {
  28.     private List<Colleague> colleagues = new ArrayList<Colleague>();
  30.     public void register(Colleague colleague) {
  31.         if (!colleagues.contains(colleague)) {
  32.             colleagues.add(colleague);
  33.             colleague.setMedium(this);
  34.         }
  35.     }
  37.     public void relay(Colleague cl) {
  38.         for (Colleague ob : colleagues) {
  39.             if (!ob.equals(cl)) {
  40.                 ((Colleague) ob).receive();
  41.             }
  42.         }
  43.     }
  44. }
  46. //抽象同事类
  47. abstract class Colleague {
  48.     protected Mediator mediator;
  50.     public void setMedium(Mediator mediator) {
  51.         this.mediator = mediator;
  52.     }
  54.     public abstract void receive();
  56.     public abstract void send();
  57. }
  59. //具体同事类
  60. class ConcreteColleague1 extends Colleague {
  61.     public void receive() {
  62.         System.out.println("具体同事类1收到请求。");
  63.     }
  65.     public void send() {
  66.         System.out.println("具体同事类1发出请求。");
  67.         mediator.relay(this); //请中介者转发
  68.     }
  69. }
  71. //具体同事类
  72. class ConcreteColleague2 extends Colleague {
  73.     public void receive() {
  74.         System.out.println("具体同事类2收到请求。");
  75.     }
  77.     public void send() {
  78.         System.out.println("具体同事类2发出请求。");
  79.         mediator.relay(this); //请中介者转发
  80.     }
  81. }

程序的运行结果如下：

具体同事类1发出请求。
具体同事类2收到请求。
——————-
具体同事类2发出请求。
具体同事类1收到请求。

模式的应用实例

【例1】用中介者模式编写一个“韶关房地产交流平台”程序。说明：韶关房地产交流平台是“房地产中介公司”提供给“卖方客户”与“买方客户”进行信息交流的平台，比较适合用中介者模式来实现。首先，定义一个中介公司（Medium）接口，它是抽象中介者，它包含了客户注册方法 register(Customer member) 和信息转发方法 relay(String from,String ad)；再定义一个韶关房地产中介（EstateMedium）公司，它是具体中介者类，它包含了保存客户信息的 List 对象，并实现了中介公司中的抽象方法。然后，定义一个客户（Customer）类，它是抽象同事类，其中包含了中介者的对象，和发送信息的 send(String ad) 方法与接收信息的 receive(String from，String ad) 方法的接口，由于本程序是窗体程序，所以本类继承 JPmme 类，并实现动作事件的处理方法 actionPerformed(ActionEvent e)。最后，定义卖方（Seller）类和买方（Buyer）类，它们是具体同事类，是客户（Customer）类的子类，它们实现了父类中的抽象方法，通过中介者类进行信息交流，其结构图如图 2 所示。中介者模式(Mediator) - 图2图2 韶关房地产交流平台的结构图
程序代码如下：

  1. package net.biancheng.c.mediator;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.ActionEvent;
  6. import java.awt.event.ActionListener;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. public class DatingPlatform {
  11.     public static void main(String[] args) {
  12.         Medium md = new EstateMedium();    //房产中介
  13.         Customer member1, member2;
  14.         member1 = new Seller("张三(卖方)");
  15.         member2 = new Buyer("李四(买方)");
  16.         md.register(member1); //客户注册
  17.         md.register(member2);
  18.     }
  19. }
  21. //抽象中介者：中介公司
  22. interface Medium {
  23.     void register(Customer member); //客户注册
  25.     void relay(String from, String ad); //转发
  26. }
  28. //具体中介者：房地产中介
  29. class EstateMedium implements Medium {
  30.     private List<Customer> members = new ArrayList<Customer>();
  32.     public void register(Customer member) {
  33.         if (!members.contains(member)) {
  34.             members.add(member);
  35.             member.setMedium(this);
  36.         }
  37.     }
  39.     public void relay(String from, String ad) {
  40.         for (Customer ob : members) {
  41.             String name = ob.getName();
  42.             if (!name.equals(from)) {
  43.                 ((Customer) ob).receive(from, ad);
  44.             }
  45.         }
  46.     }
  47. }
  49. //抽象同事类：客户
  50. abstract class Customer extends JFrame implements ActionListener {
  51.     private static final long serialVersionUID = -7219939540794786080L;
  52.     protected Medium medium;
  53.     protected String name;
  54.     JTextField SentText;
  55.     JTextArea ReceiveArea;
  57.     public Customer(String name) {
  58.         super(name);
  59.         this.name = name;
  60.     }
  62.     void ClientWindow(int x, int y) {
  63.         Container cp;
  64.         JScrollPane sp;
  65.         JPanel p1, p2;
  66.         cp = this.getContentPane();
  67.         SentText = new JTextField(18);
  68.         ReceiveArea = new JTextArea(10, 18);
  69.         ReceiveArea.setEditable(false);
  70.         p1 = new JPanel();
  71.         p1.setBorder(BorderFactory.createTitledBorder("接收内容："));
  72.         p1.add(ReceiveArea);
  73.         sp = new JScrollPane(p1);
  74.         cp.add(sp, BorderLayout.NORTH);
  75.         p2 = new JPanel();
  76.         p2.setBorder(BorderFactory.createTitledBorder("发送内容："));
  77.         p2.add(SentText);
  78.         cp.add(p2, BorderLayout.SOUTH);
  79.         SentText.addActionListener(this);
  80.         this.setLocation(x, y);
  81.         this.setSize(250, 330);
  82.         this.setResizable(false); //窗口大小不可调整
  83.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  84.         this.setVisible(true);
  85.     }
  87.     public void actionPerformed(ActionEvent e) {
  88.         String tempInfo = SentText.getText().trim();
  89.         SentText.setText("");
  90.         this.send(tempInfo);
  91.     }
  93.     public String getName() {
  94.         return name;
  95.     }
  97.     public void setMedium(Medium medium) {
  98.         this.medium = medium;
  99.     }
  101.     public abstract void send(String ad);
  103.     public abstract void receive(String from, String ad);
  104. }
  106. //具体同事类：卖方
  107. class Seller extends Customer {
  108.     private static final long serialVersionUID = -1443076716629516027L;
  110.     public Seller(String name) {
  111.         super(name);
  112.         ClientWindow(50, 100);
  113.     }
  115.     public void send(String ad) {
  116.         ReceiveArea.append("我(卖方)说: " + ad + "\n");
  117.         //使滚动条滚动到最底端
  118.         ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
  119.         medium.relay(name, ad);
  120.     }
  122.     public void receive(String from, String ad) {
  123.         ReceiveArea.append(from + "说: " + ad + "\n");
  124.         //使滚动条滚动到最底端
  125.         ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
  126.     }
  127. }
  129. //具体同事类：买方
  130. class Buyer extends Customer {
  131.     private static final long serialVersionUID = -474879276076308825L;
  133.     public Buyer(String name) {
  134.         super(name);
  135.         ClientWindow(350, 100);
  136.     }
  138.     public void send(String ad) {
  139.         ReceiveArea.append("我(买方)说: " + ad + "\n");
  140.         //使滚动条滚动到最底端
  141.         ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
  142.         medium.relay(name, ad);
  143.     }
  145.     public void receive(String from, String ad) {
  146.         ReceiveArea.append(from + "说: " + ad + "\n");
  147.         //使滚动条滚动到最底端
  148.         ReceiveArea.setCaretPosition(ReceiveArea.getText().length());
  149.     }
  150. }

模式的应用场景

前面分析了中介者模式的结构与特点，下面分析其以下应用场景。

  • 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
  • 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

    模式的扩展

    在实际开发中，通常采用以下两种方法来简化中介者模式，使开发变得更简单。
  1. 不定义中介者接口，把具体中介者对象实现成为单例。
  2. 同事对象不持有中介者，而是在需要的时候直接获取中介者对象并调用。

图 4 所示是简化中介者模式的结构图。中介者模式(Mediator) - 图3图4 简化中介者模式的结构图
程序代码如下：

  1. package net.biancheng.c.mediator;
  3. import java.util.*;
  5. public class SimpleMediatorPattern {
  6.     public static void main(String[] args) {
  7.         SimpleColleague c1, c2;
  8.         c1 = new SimpleConcreteColleague1();
  9.         c2 = new SimpleConcreteColleague2();
  10.         c1.send();
  11.         System.out.println("-----------------");
  12.         c2.send();
  13.     }
  14. }
  16. //简单单例中介者
  17. class SimpleMediator {
  18.     private static SimpleMediator smd = new SimpleMediator();
  19.     private List<SimpleColleague> colleagues = new ArrayList<SimpleColleague>();
  21.     private SimpleMediator() {
  22.     }
  24.     public static SimpleMediator getMedium() {
  25.         return (smd);
  26.     }
  28.     public void register(SimpleColleague colleague) {
  29.         if (!colleagues.contains(colleague)) {
  30.             colleagues.add(colleague);
  31.         }
  32.     }
  34.     public void relay(SimpleColleague scl) {
  35.         for (SimpleColleague ob : colleagues) {
  36.             if (!ob.equals(scl)) {
  37.                 ((SimpleColleague) ob).receive();
  38.             }
  39.         }
  40.     }
  41. }
  43. //抽象同事类
  44. interface SimpleColleague {
  45.     void receive();
  47.     void send();
  48. }
  50. //具体同事类
  51. class SimpleConcreteColleague1 implements SimpleColleague {
  52.     SimpleConcreteColleague1() {
  53.         SimpleMediator smd = SimpleMediator.getMedium();
  54.         smd.register(this);
  55.     }
  57.     public void receive() {
  58.         System.out.println("具体同事类1：收到请求。");
  59.     }
  61.     public void send() {
  62.         SimpleMediator smd = SimpleMediator.getMedium();
  63.         System.out.println("具体同事类1：发出请求...");
  64.         smd.relay(this); //请中介者转发
  65.     }
  66. }
  68. //具体同事类
  69. class SimpleConcreteColleague2 implements SimpleColleague {
  70.     SimpleConcreteColleague2() {
  71.         SimpleMediator smd = SimpleMediator.getMedium();
  72.         smd.register(this);
  73.     }
  75.     public void receive() {
  76.         System.out.println("具体同事类2：收到请求。");
  77.     }
  79.     public void send() {
  80.         SimpleMediator smd = SimpleMediator.getMedium();
  81.         System.out.println("具体同事类2：发出请求...");
  82.         smd.relay(this); //请中介者转发
  83.     }
  84. }

程序运行结果如下：

具体同事类1：发出请求…
具体同事类2：收到请求。
————————-
具体同事类2：发出请求…
具体同事类1：收到请求。