学习设计模式不光要学习设计模式的思想,还要去深入理解,为什么要用这个设计模式。
如何深入理解?读优秀的框架代码,看别人代码,了解它们的使用场景。 - - - 博主老师(感谢他)
本文先介绍了策略模式的概念及简单实现。没找经典实现,太困了~
1、概念
定义:中介者模式((Mediator Pattern)包装了一系列对象互相作用的方式,使得这些对象不必互相明显作用。从而使它们可以松散耦合。
中介者模式将多对多的互相作用转化为一对多的互相作用。
例如,做Javaweb开发的,应该都知道spring mvc吧,这里的mvc也是中介者的体现
mvc:Model(模型)、View(视图)和Controller(控制)
从结构上可以分三层:
-
最上面的一层,是直接面向最终用户的"视图层"(View)。它是提供给用户的操作界面,是程序的外壳。
-
最底下的一层,是核心的"数据层"(Model),也就是程序需要操作的数据或信息。
-
中间的一层,就是"控制层"(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