1、定义

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

2、模式结构

中介者（Mediator）模式 - 图1

中介者模式由四部分组成：

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

3、实例

3.1 抽象数据库类（Colleague）

  1. public abstract class AbstractDatabase {
  3.     public static final String MYSQL = "mysql";
  4.     public static final String REDIS = "redis";
  5.     public static final String ELASTICSEARCH = "elasticsearch";
  7.     public AbstractMediator mediator;
  9.     public AbstractDatabase(AbstractMediator mediator) {
  10.         this.mediator = mediator;
  11.     }
  14.     public abstract void addData(String data);
  16.     public abstract void add(String data);
  17. }

3.2 ConcreteMeidator

  1. public class MysqlDatabase extends AbstractDatabase {
  3.     private List<String> dataList = null;
  5.     public MysqlDatabase(AbstractMediator mediator) {
  6.         super(mediator);
  7.         dataList = new ArrayList<>();
  8.     }
  10.     @Override
  11.     public void addData(String data) {
  12.         System.out.println("Mysql 添加数据：" + data);
  13.         dataList.add(data);
  14.     }
  16.     @Override
  17.     public void add(String data) {
  18.         addData(data);
  19.         // 同步数据交给中介者
  20.         mediator.sync(AbstractDatabase.MYSQL, data);
  21.     }
  23.     public void select() {
  24.         System.out.println("Mysql查询，数据：" + dataList.toString());
  25.     }
  26. }
  1. public class RedisDatabase extends AbstractDatabase {
  3.     private List<String> dataList = null;
  5.     public RedisDatabase(AbstractMediator mediator) {
  6.         super(mediator);
  7.         dataList = new ArrayList<>();
  8.     }
  10.     @Override
  11.     public void addData(String data) {
  12.         System.out.println("Redis 添加数据：" + data);
  13.         dataList.add(data);
  14.     }
  16.     @Override
  17.     public void add(String data) {
  18.         addData(data);
  19.         // 同步数据交给中介者
  20.         mediator.sync(AbstractDatabase.REDIS, data);
  21.     }
  23.     public void cache() {
  24.         System.out.println("Redis 缓存的数据：" + dataList.toString());
  25.     }
  26. }
  1. public class ESDatabase extends AbstractDatabase {
  3.     private List<String> dataList = null;
  5.     public ESDatabase(AbstractMediator mediator) {
  6.         super(mediator);
  7.         dataList = new ArrayList<>();
  8.     }
  10.     @Override
  11.     public void addData(String data) {
  12.         System.out.println("ES 添加数据：" + data);
  13.         dataList.add(data);
  14.     }
  16.     @Override
  17.     public void add(String data) {
  18.         addData(data);
  19.         // 同步数据交给中介者
  20.         mediator.sync(AbstractDatabase.ELASTICSEARCH, data);
  21.     }
  23.     public void count() {
  24.         System.out.println("Elasticsearch 统计，目前有 " + dataList.size() + " 条数据，数据：" + this.dataList.toString());
  25.     }
  26. }

3.3 Mediator

  1. public abstract class AbstractMediator {
  3.     protected MysqlDatabase mysql;
  4.     protected RedisDatabase redis;
  5.     protected ESDatabase es;
  7.     // getter和setter
  9.     public abstract void sync(String databaseName, String data);
  10. }

3.4 ConcreteMeidiator

  1. public class SyncMediator extends AbstractMediator {
  3.     @Override
  4.     public void sync(String databaseName, String data) {
  5.         if (AbstractDatabase.MYSQL.equals(databaseName)) {
  6.             // 同步到redis和Elasticsearch
  7.             redis.addData(data);
  8.             es.addData(data);
  9.         } else if (AbstractDatabase.ELASTICSEARCH.equals(databaseName)) {
  10.             // 同步到mysql
  11.             mysql.addData(data);
  12.         } else if (AbstractDatabase.REDIS.equals(databaseName)) {
  13.             // 不需要同步
  14.         }
  15.     }
  16. }

3.5 客户端调用

  1. public class Client {
  3.     public static void main(String[] args) {
  5.         AbstractMediator mediator = new SyncMediator();
  7.         MysqlDatabase mysql = new MysqlDatabase(mediator);
  8.         RedisDatabase redis = new RedisDatabase(mediator);
  9.         ESDatabase es = new ESDatabase(mediator);
  11.         mediator.setMysql(mysql);
  12.         mediator.setRedis(redis);
  13.         mediator.setEs(es);
  15.         System.out.println("\n------向mysql添加数据“小白”------");
  16.         mysql.add("小白");
  17.         mysql.select();
  18.         redis.cache();
  19.         es.count();
  21.         System.out.println("\n------向redis添加数据“小明”------");
  22.         redis.add("小明");
  23.         mysql.select();
  24.         redis.cache();
  25.         es.count();
  27.         System.out.println("\n------向ES添加数据“小红”------");
  28.         es.add("小红");
  29.         mysql.select();
  30.         redis.cache();
  31.         es.count();
  32.     }
  33. }

4、适用场景

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

5、优缺点

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

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