一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下图中,有六个同事类对象,假如对象1发生变化,那么将会有4个对象受到影响。如果对象2发生变化,那么将会有5个对象受到影响。也就是说,同事类之间直接关联的设计是不好的。
如果引入中介者模式,那么同事类之间的关系将变为星型结构,从图中可以看到,任何一个类的变动,只会影响的类本身,以及中介者,这样就减小了系统的耦合。一个好的设计,必定不会把所有的对象关系处理逻辑封装在本类中,而是使用一个专门的类来管理那些不属于自己的行为。
中介者模式(Mediator Pattern):用一个中介对象(中介者)来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式,它是一种对象行为型模式。
中介者模式的核心在于中介者类的引入,在中介者模式中,中介者类承担了两方面的职责:
开发中常见的场景
我们来实现一个简化版的数据同步方案,有三种数据库 Mysql
、Redis
、Elasticsearch
,
所以它们之间的关系图如下所示。
抽象数据库
public abstract class AbstractDatabase { //存储数据 protected LinkedList<String> datas=new LinkedList<>(); //向自己的数据库中增加数据的方法 public abstract void addData(String data); //同步数据的方法--默认空实现 public void DataStore(String data){} //展示当前数据库所有数据 public void display() { datas.forEach(x->System.out.println(x)); } }
具体数据库 Mysql,维护同步到 Redis和Elasticsearch 的同步作业
public class MySql extends AbstractDatabase { @Setter private Elasticsearch elasticsearch; @Setter private Redis redis; //向自己的数据库增加数据 @Override public void addData(String data) { System.out.println("====向Mysql数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } //重写父类数据同步的方法 @Override public void DataStore(String data) { addData(data); elasticsearch.addData(data); redis.addData(data); } }
Elasticsearch ,只需要同步到Mysql
public class Elasticsearch extends AbstractDatabase { @Setter private MySql mySql; //给自己增加数据的方法 @Override public void addData(String data) { System.out.println("====向Elasticsearch数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } //重写父类数据同步的方法 @Override public void DataStore(String data) { addData(data); //数据同步 mySql.addData(data); } }
具体数据库 Redis,不需要同步到其它数据库
public class Redis extends AbstractDatabase { //给自己增加数据的方法 @Override public void addData(String data) { System.out.println("====向Redis数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } }
客户端测试:
public class Client { public static void main(String[] args) { Elasticsearch elasticsearch=new Elasticsearch(); MySql mySql=new MySql(); Redis redis=new Redis(); elasticsearch.setMySql(mySql); mySql.setElasticsearch(elasticsearch); mySql.setRedis(redis); //增加数据 mySql.DataStore("大忽悠"); elasticsearch.DataStore("李窈"); redis.addData("小朋友"); System.out.println("mysql数据库中的数据如下:"); mySql.display(); System.out.println("elasticsearch数据库中的数据如下:"); elasticsearch.display(); System.out.println("redis数据库中数据如下:"); redis.display(); } }
抽象中介者:
//抽象中介者 @Data public abstract class AbstractMediator { protected MySql mySql; protected Elasticsearch elasticsearch; protected Redis redis; public abstract void sync(String databaseName, String data); }
首先还是抽象数据库类(抽象同事类),维护了一个中介者
public abstract class AbstractDatabase { public static final String MYSQL="mysql"; public static final String Elasticsearch="elasticsearch"; public static final String REDIS="redis"; //保存一个中介者对象 @Setter protected AbstractMediator Mediator; //存储数据 protected LinkedList<String> datas=new LinkedList<>(); //向自己的数据库中增加数据的方法 public abstract void addData(String data); //同步数据的方法--默认空实现 public void DataStore(String data){} //展示当前数据库所有数据 public void display() { datas.forEach(x->System.out.println(x)); } }
Mysql 数据库(具体同事类)
public class MySql extends AbstractDatabase { //向自己的数据库增加数据 @Override public void addData(String data) { System.out.println("====向Mysql数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } //重写父类数据同步的方法 @Override public void DataStore(String data) { addData(data); //将数据同步到redis和elasticsearch的工作由中介完成 mediator.sync(AbstractDatabase.MYSQL,data); } }
Redis 数据库(具体同事类)
public class Redis extends AbstractDatabase { //给自己增加数据的方法 @Override public void addData(String data) { System.out.println("====向Redis数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } //重新父类同步数据的方法 @Override public void DataStore(String data) { addData(data); //同步数据的工作交给中介 mediator.sync(AbstractDatabase.REDIS,data); } }
Elasticsearch(具体同事类)
public class Elasticsearch extends AbstractDatabase { //给自己增加数据的方法 @Override public void addData(String data) { System.out.println("====向Elasticsearch数据库增加一条数据===="); System.out.println("增加的数据为:"+data); System.out.println("====================================="); datas.add(data); } //重写父类数据同步的方法 @Override public void DataStore(String data) { addData(data); //数据同步 mediator.sync(AbstractDatabase.Elasticsearch,data); } }
具体中介者:
public class SyncMediator extends AbstractMediator { @Override public void sync(String databaseName, String data) { if (AbstractDatabase.MYSQL.equals(databaseName)) { // mysql 同步到 redis 和 Elasticsearch this.redis.addData(data); this.elasticsearch.addData(data); } else if (AbstractDatabase.REDIS.equals(databaseName)) { // redis 缓存同步,不需要同步到其他数据库 } else if (AbstractDatabase.Elasticsearch.equals(databaseName)) { // Elasticsearch 同步到 Mysql this.mySql.addData(data); } } }
测试客户端
public class Client { public static void main(String[] args) { AbstractMediator mediator=new SyncMediator(); Elasticsearch elasticsearch=new Elasticsearch(); MySql mySql=new MySql(); Redis redis=new Redis(); elasticsearch.setMediator(mediator); mySql.setMediator(mediator); redis.setMediator(mediator); mediator.setMySql(mySql); mediator.setElasticsearch(elasticsearch); mediator.setRedis(redis); //增加数据 mySql.DataStore("大忽悠"); elasticsearch.DataStore("李窈"); redis.DataStore("小朋友"); System.out.println("mysql数据库中的数据如下:"); mySql.display(); System.out.println("elasticsearch数据库中的数据如下:"); elasticsearch.display(); System.out.println("redis数据库中数据如下:"); redis.display(); } }
敲一个 java.util.Timer 的Demo
两个任务类
public class MyOneTask extends TimerTask { private static int num = 0; @Override public void run() { System.out.println("I'm MyOneTask " + ++num); } } public class MyTwoTask extends TimerTask { private static int num = 1000; @Override public void run() { System.out.println("I'm MyTwoTask " + num--); } }
客户端测试,3秒后开始执行,循环周期为 1秒
public class TimerTest { public static void main(String[] args) { // 注意:多线程并行处理定时任务时,Timer运行多个TimeTask时,只要其中之一没有捕获抛出的异常, // 其它任务便会自动终止运行,使用ScheduledExecutorService则没有这个问题 Timer timer = new Timer(); timer.schedule(new MyOneTask(), 3000, 1000); // 3秒后开始运行,循环周期为 1秒 timer.schedule(new MyTwoTask(), 3000, 1000); } }
Timer 的部分关键源码如下
public class Timer { private final TaskQueue queue = new TaskQueue(); private final TimerThread thread = new TimerThread(queue); public void schedule(TimerTask task, long delay) { if (delay < 0) throw new IllegalArgumentException("Negative delay."); sched(task, System.currentTimeMillis()+delay, 0); } public void schedule(TimerTask task, Date time) { sched(task, time.getTime(), 0); } private void sched(TimerTask task, long time, long period) { if (time < 0) throw new IllegalArgumentException("Illegal execution time."); if (Math.abs(period) > (Long.MAX_VALUE >> 1)) period >>= 1; // 获取任务队列的锁(同一个线程多次获取这个锁并不会被阻塞,不同线程获取时才可能被阻塞) synchronized(queue) { // 如果定时调度线程已经终止了,则抛出异常结束 if (!thread.newTasksMayBeScheduled) throw new IllegalStateException("Timer already cancelled."); // 再获取定时任务对象的锁(为什么还要再加这个锁呢?想不清) synchronized(task.lock) { // 判断线程的状态,防止多线程同时调度到一个任务时多次被加入任务队列 if (task.state != TimerTask.VIRGIN) throw new IllegalStateException( "Task already scheduled or cancelled"); // 初始化定时任务的下次执行时间 task.nextExecutionTime = time; // 重复执行的间隔时间 task.period = period; // 将定时任务的状态由TimerTask.VIRGIN(一个定时任务的初始化状态)设置为TimerTask.SCHEDULED task.state = TimerTask.SCHEDULED; } // 将任务加入任务队列 queue.add(task); // 如果当前加入的任务是需要第一个被执行的(也就是他的下一次执行时间离现在最近) // 则唤醒等待queue的线程(对应到上面提到的queue.wait()) if (queue.getMin() == task) queue.notify(); } } // cancel会等到所有定时任务执行完后立刻终止定时线程 public void cancel() { synchronized(queue) { thread.newTasksMayBeScheduled = false; queue.clear(); queue.notify(); // In case queue was already empty. } } // ... }
Timer
中在 schedulexxx
方法中通过 TaskQueue
协调各种 TimerTask 定时任务,Timer 是中介者,TimerTask 是抽象同事类,而我们自己写的任务则是具体同事类
TimerThread
是 Timer
中定时调度线程类的定义,这个类会做为一个线程一直运行来执行 Timer 中任务队列中的任务。
Timer 这个中介者的功能就是定时调度我们写的各种任务,将任务添加到 TaskQueue 任务队列中,给 TimerThread 执行,让任务与执行线程解耦
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!