服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Java设计模式之java中介者模式详解

Java设计模式之java中介者模式详解

2022-01-04 00:46大忽悠爱忽悠 Java教程

这篇文章主要为大家详细介绍了23种设计模式之java中介者模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助

 

引言

一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下图中,有六个同事类对象,假如对象1发生变化,那么将会有4个对象受到影响。如果对象2发生变化,那么将会有5个对象受到影响。也就是说,同事类之间直接关联的设计是不好的。

Java设计模式之java中介者模式详解

如果引入中介者模式,那么同事类之间的关系将变为星型结构,从图中可以看到,任何一个类的变动,只会影响的类本身,以及中介者,这样就减小了系统的耦合。一个好的设计,必定不会把所有的对象关系处理逻辑封装在本类中,而是使用一个专门的类来管理那些不属于自己的行为。

Java设计模式之java中介者模式详解

 

介绍

中介者模式(Mediator Pattern):用一个中介对象(中介者)来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式,它是一种对象行为型模式。

 

角色

  • Mediator(抽象中介者):它定义一个接口,该接口用于与各同事对象之间进行通信。
  • ConcreteMediator(具体中介者):它是抽象中介者的子类,通过协调各个同事对象来实现协作行为,它维持了对各个同事对象的引用。
  • Colleague(抽象同事类):它定义各个同事类公有的方法,并声明了一些抽象方法来供子类实现,同时它维持了一个对抽象中介者类的引用,其子类可以通过该引用来与中介者通信。
  • ConcreteColleague(具体同事类):它是抽象同事类的子类;每一个同事对象在需要和其他同事对象通信时,先与中介者通信,通过中介者来间接完成与其他同事类的通信;在具体同事类中实现了在抽象同事类中声明的抽象方法。

中介者模式的核心在于中介者类的引入,在中介者模式中,中介者类承担了两方面的职责:

  • 中转作用(结构性):通过中介者提供的中转作用,各个同事对象就不再需要显式引用其他同事,当需要和其他同事进行通信时,可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。
  • 协调作用(行为性):中介者可以更进一步的对同事之间的关系进行封装,同事可以一致的和中介者进行交互,而不需要指明中介者需要具体怎么做,中介者根据封装在自身内部的协调逻辑,对同事的请求进行进一步处理,将同事成员之间的关系行为进行分离和封装。

开发中常见的场景

  • MVC模式(Controller 是中介者,根据 View 层的请求来操作 Model 层)
  • 窗口游戏程序,窗口软件开发中窗口对象也是一个中介者对象
  • 图形界面开发GUI中,多个组件之间的交互,可以通过引入一个中介者对象来解决,可以是整体的窗口对象或者DOM对象
  • Java.lang.reflect.Method#invoke()

 

数据库同步数据案例

我们来实现一个简化版的数据同步方案,有三种数据库 MysqlRedisElasticsearch

  • 其中的 Mysql 作为主数据库,当增加一条数据时需要同步到另外两个数据库中;
  • Redis 作为缓存数据库,当增加一条数据时不需要同步到另外另个数据库;
  • 而 Elasticsearch 作为大数据查询数据库,有一个统计功能,当增加一条数据时只需要同步到 Mysql,

所以它们之间的关系图如下所示。

Java设计模式之java中介者模式详解

 

不使用中介者模式的数据同步方案,各数据源维护各自的同步作业

抽象数据库

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();
    }
}

Java设计模式之java中介者模式详解

 

其实这样已经实现了我们的需求,但是存在一些问题

  • 系统结构复杂且耦合度高。数据源需要维护目标端数据库的引用,以便完成数据同步
  • 组件的可重用性差。由于每一个数据源和目标端之间具有很强的关联,若没有目标端的支持,这个组件很难被另一个系统或模块重用
  • 系统的可扩展性差:如果需要增加、修改或删除其中一个数据库、将导致多个类的源代码需要修改,这违反了“开闭原则”,可扩展性和灵活性欠佳。

 

中介者模式来重构,将数据同步的功能迁移到中介者中,由中介者来管理数据同步作业

抽象中介者:

//抽象中介者
@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设计模式之java中介者模式详解

 

小结

 

主要优点

  • 中介者模式简化了对象之间的交互,它用中介者和同事的一对多交互代替了原来同事之间的多对多交互,一对多关系更容易理解、维护和扩展,将原本难以理解的网状结构转换成相对简单的星型结构。
  • 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合,我们可以独立的改变和复用每一个同事和中介者,增加新的中介者和新的同事类都比较方便,更好地符合 “开闭原则”。
  • 可以减少子类生成,中介者将原本分布于多个对象间的行为集中在一起,改变这些行为只需生成新的中介者子类即可,这使各个同事类可被重用,无须对同事类进行扩展。

 

中介者模式的主要缺点

  • 在具体中介者类中包含了大量同事之间的交互细节,可能会导致具体中介者类非常复杂,使得系统难以维护。(也就是把具体同事类之间的交互复杂性集中到了中介者类中,结果中介者成了最复杂的类)

 

适用场景

  • 系统中对象之间存在复杂的引用关系,系统结构混乱且难以理解。
  • 一个对象由于引用了其他很多对象并且直接和这些对象通信,导致难以复用该对象。
  • 想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。可以通过引入中介者类来实现,在中介者中定义对象交互的公共行为,如果需要改变行为则可以增加新的具体中介者类

 

具体应用

 

Java Timer 中的中介者模式

敲一个 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):中介者模式

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/m0_53157173/article/details/120212092

延伸 · 阅读

精彩推荐