设计模式：中介者模式-概念、实现

学习设计模式不光要学习设计模式的思想，还要去深入理解，为什么要用这个设计模式。
如何深入理解？读优秀的框架代码，看别人代码，了解它们的使用场景。 - - - 博主老师（感谢他）

本文先介绍了策略模式的概念及简单实现。没找经典实现，太困了~

1、概念

定义：中介者模式((Mediator Pattern)包装了一系列对象互相作用的方式，使得这些对象不必互相明显作用。从而使它们可以松散耦合。

中介者模式将多对多的互相作用转化为一对多的互相作用。

例如，做Javaweb开发的，应该都知道spring mvc吧，这里的mvc也是中介者的体现

mvc：Model（模型）、View（视图）和Controller（控制）
从结构上可以分三层：

1. 最上面的一层，是直接面向最终用户的"视图层"（View）。它是提供给用户的操作界面，是程序的外壳。

2. 最底下的一层，是核心的"数据层"（Model），也就是程序需要操作的数据或信息。

3. 中间的一层，就是"控制层"（Controller），它负责根据用户从"视图层"输入的指令，选取"数据层"中的数据，然后对其进行相应的操作，产生最终结果。

这里的控制层就是中介者

2、实现

为保证数据安全，某公司所有的数据同时存到了两个数据库中，主备强同步。且为了提高效率，用到了缓存。
主数据库：rds1
备数据库：rds2
缓存数据库：redis

数据写到rds1, 需要同步到rds2及redis
数据写到rds2，需要同步到rds1及redis
数据写到redis，不需要同步任何库

中介者抽象

public abstract class AbstractMediator {

    protected Rds1 rds1;

    protected Rds2 rds2;

    protected Cache cache;

    public abstract void sync(String databaseName, String data);

    public void setRds1(Rds1 rds1) {
        this.rds1 = rds1;
    }

    public void setRds2(Rds2 rds2) {
        this.rds2 = rds2;
    }

    public void setCache(Cache cache) {
        this.cache = cache;
    }
}

数据库抽象

public abstract class AbstractDatabase {
    List<String> dataList = new ArrayList<>();

    public static final String RDS1 = "rds1";
    public static final String RDS2 = "rds2";
    public static final String CACHE = "cache";

    protected AbstractMediator abstractMediator;

    public AbstractDatabase(AbstractMediator abstractMediator) {
        this.abstractMediator = abstractMediator;
    }

    public abstract void add(String data);

    public abstract void addData(String data);

    public abstract void show();

}

rds1

public class Rds1 extends AbstractDatabase {


    public Rds1(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    @Override
    public void add(String data) {
        abstractMediator.sync(RDS1, data);
    }

    @Override
    public void addData(String data) {
        dataList.add(data);
    }
    public void show() {
        System.out.println("rds1：" + dataList.toString());
    }
}

rds2

public class Rds2 extends AbstractDatabase{

    public Rds2(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    @Override
    public void add(String data) {
        abstractMediator.sync(RDS2, data);
    }

    @Override
    public void addData(String data) {
        dataList.add(data);
    }
    public void show() {
        System.out.println("rds2：" + dataList.toString());
    }
}

cache

public class Cache extends AbstractDatabase {

    public Cache(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    @Override
    public void add(String data) {
        abstractMediator.sync(CACHE, data);
    }

    @Override
    public void addData(String data) {
        dataList.add(data);
    }
    public void show() {
        System.out.println("cache：" + dataList.toString());
    }
}

数据同步中介者

public class SyncMediator extends AbstractMediator {
    @Override
    public void sync(String databaseName, String data) {
        if (AbstractDatabase.RDS1.equals(databaseName) || AbstractDatabase.RDS2.equals(databaseName)) {
            this.rds1.addData(data);
            this.rds2.addData(data);
            this.cache.addData(data);
        } else {
            this.cache.addData(data);
        }
    }
}

测试类

public static void main(String[] args) {
    AbstractMediator abstractMediator = new SyncMediator();
    Rds1 rds1 = new Rds1(abstractMediator);
    Rds2 rds2 = new Rds2(abstractMediator);
    Cache cache = new Cache(abstractMediator);

    abstractMediator.setRds1(rds1);
    abstractMediator.setRds2(rds2);
    abstractMediator.setCache(cache);

    System.out.println("往rds1中添加数据:");
    rds1.add("a");
    show(rds1, rds2, cache);

    System.out.println("往rds2中添加数据:");
    rds2.add("b");
    show(rds1, rds2, cache);

    System.out.println("往cache中添加数据:");
    cache.add("c");
    show(rds1, rds2, cache);


}

private static void show(Rds1 rds1, Rds2 rds2, Cache cache) {
    rds1.show();
    rds2.show();
    cache.show();
}

输出

往rds1中添加数据:
rds1：[a]
rds2：[a]
cache：[a]
往rds2中添加数据:
rds1：[a, b]
rds2：[a, b]
cache：[a, b]
往cache中添加数据:
rds1：[a, b]
rds2：[a, b]
cache：[a, b, c]

总结：

中介者模式把握住一点：多对象解耦（多对多关系变一对多关系）

但是中介者责任过重，也容易把程序变得复杂。

---

数据同步例子参考自:https://blog.csdn.net/wwwdc1012/article/details/83389158
mvc:http://www.ruanyifeng.com/blog/2007/11/mvc.html