Python 官方文档:入门教程 => 点击学习
目录引言介绍角色数据库同步数据案例不使用中介者模式的数据同步方案,各数据源维护各自的同步作业其实这样已经实现了我们的需求,但是存在一些问题中介者模式来重构,将数据同步的功能迁移到中介
一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下图中,有六个同事类对象,假如对象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 执行,让任务与执行线程解耦
设计模式之中介者模式
23种设计模式(7):中介者模式
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注编程网的更多内容!
--结束END--
本文标题: Java设计模式之java中介者模式详解
本文链接: https://www.lsjlt.com/news/135771.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑,方便收藏和打印~
2024-03-01
2024-03-01
2024-03-01
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
0