23种设计模式之中介者（Mediator）模式

1、定义

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

2、模式结构

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

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

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

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

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

3、实例

3.1 抽象数据库类（Colleague）

public abstract class AbstractDatabase {
    
    public static final String MYSQL = "mysql";
    public static final String REDIS = "redis";
    public static final String ELASTICSEARCH = "elasticsearch";
    
    public AbstractMediator mediator;
    
    public AbstractDatabase(AbstractMediator mediator) {
        this.mediator = mediator;
    }

    
    public abstract void addData(String data);
    
    public abstract void add(String data);
}

3.2 ConcreteMeidator

public class MysqlDatabase extends AbstractDatabase {
    
    private List<String> dataList = null;
    
    public MysqlDatabase(AbstractMediator mediator) {
        super(mediator);
        dataList = new ArrayList<>();
    }
    
    @Override
    public void addData(String data) {
        System.out.println("Mysql 添加数据：" + data);
        dataList.add(data);
    }
    
    @Override
    public void add(String data) {
        addData(data);
        // 同步数据交给中介者
        mediator.sync(AbstractDatabase.MYSQL, data);
    }
    
    public void select() {
        System.out.println("Mysql查询，数据：" + dataList.toString());
    }
}

public class RedisDatabase extends AbstractDatabase {
    
    private List<String> dataList = null;
    
    public RedisDatabase(AbstractMediator mediator) {
        super(mediator);
        dataList = new ArrayList<>();
    }
    
    @Override
    public void addData(String data) {
        System.out.println("Redis 添加数据：" + data);
        dataList.add(data);
    }
    
    @Override
    public void add(String data) {
        addData(data);
        // 同步数据交给中介者
        mediator.sync(AbstractDatabase.REDIS, data);
    }
    
    public void cache() {
        System.out.println("Redis 缓存的数据：" + dataList.toString());
    }
}

public class ESDatabase extends AbstractDatabase {
    
    private List<String> dataList = null;
    
    public ESDatabase(AbstractMediator mediator) {
        super(mediator);
        dataList = new ArrayList<>();
    }
    
    @Override
    public void addData(String data) {
        System.out.println("ES 添加数据：" + data);
        dataList.add(data);
    }
    
    @Override
    public void add(String data) {
        addData(data);
        // 同步数据交给中介者
        mediator.sync(AbstractDatabase.ELASTICSEARCH, data);
    }
    
    public void count() {
        System.out.println("Elasticsearch 统计，目前有 " + dataList.size() + " 条数据，数据：" + this.dataList.toString());
    }
}

3.3 Mediator

public abstract class AbstractMediator {
    
    protected MysqlDatabase mysql;
    protected RedisDatabase redis;
    protected ESDatabase es;
    
    // getter和setter
    
    public abstract void sync(String databaseName, String data);
}

3.4 ConcreteMeidiator

public class SyncMediator extends AbstractMediator {

    @Override
    public void sync(String databaseName, String data) {
        if (AbstractDatabase.MYSQL.equals(databaseName)) {
            // 同步到redis和Elasticsearch
            redis.addData(data);
            es.addData(data);
        } else if (AbstractDatabase.ELASTICSEARCH.equals(databaseName)) {
            // 同步到mysql
            mysql.addData(data);
        } else if (AbstractDatabase.REDIS.equals(databaseName)) {
            // 不需要同步
        }
    }
}

3.5 客户端调用

public class Client {

    public static void main(String[] args) {

        AbstractMediator mediator = new SyncMediator();

        MysqlDatabase mysql = new MysqlDatabase(mediator);
        RedisDatabase redis = new RedisDatabase(mediator);
        ESDatabase es = new ESDatabase(mediator);

        mediator.setMysql(mysql);
        mediator.setRedis(redis);
        mediator.setEs(es);

        System.out.println("\n------向mysql添加数据“小白”------");
        mysql.add("小白");
        mysql.select();
        redis.cache();
        es.count();

        System.out.println("\n------向redis添加数据“小明”------");
        redis.add("小明");
        mysql.select();
        redis.cache();
        es.count();

        System.out.println("\n------向ES添加数据“小红”------");
        es.add("小红");
        mysql.select();
        redis.cache();
        es.count();
    }
}

4、适用场景

系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。

一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。

想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。

交互的公共行为，如果需要改变行为则可以增加新的中介者类。

5、优缺点

5.1 优点

简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原来难以理解的网状结构转换成相对简单的星型结构。

将各个同事对象解耦，中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便。

减少子类生成，中介者将原来分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中间者子类即可，这使各个同事类可被重用，无须对同事类进行扩展。

5.2 缺点

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

源代码：github.com/freedom9/de…