欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java設計模式之java中介者模式詳解

 更新時間：2021年09月15日 11:09:21   作者：大忽悠愛忽悠  
這篇文章主要為大家詳細介紹了23種設計模式之java中介者模式，具有一定的參考價值，感興趣的小伙伴們可以參考一下,希望能夠給你帶來幫助

引言

一般來說，同事類之間的關系是比較復雜的，多個同事類之間互相關聯時，他們之間的關系會呈現為復雜的網狀結構，這是一種過度耦合的架構，即不利于類的復用，也不穩(wěn)定。例如在下圖中，有六個同事類對象，假如對象1發(fā)生變化，那么將會有4個對象受到影響。如果對象2發(fā)生變化，那么將會有5個對象受到影響。也就是說，同事類之間直接關聯的設計是不好的。

在這里插入圖片描述

如果引入中介者模式，那么同事類之間的關系將變?yōu)樾切徒Y構，從圖中可以看到，任何一個類的變動，只會影響的類本身，以及中介者，這樣就減小了系統的耦合。一個好的設計，必定不會把所有的對象關系處理邏輯封裝在本類中，而是使用一個專門的類來管理那些不屬于自己的行為。

在這里插入圖片描述

介紹

中介者模式(Mediator Pattern)：用一個中介對象（中介者）來封裝一系列的對象交互，中介者使各對象不需要顯式地相互引用，從而使其耦合松散，而且可以獨立地改變它們之間的交互。中介者模式又稱為調停者模式，它是一種對象行為型模式。

角色

  • Mediator（抽象中介者）：它定義一個接口，該接口用于與各同事對象之間進行通信。
  • ConcreteMediator（具體中介者）：它是抽象中介者的子類，通過協調各個同事對象來實現協作行為，它維持了對各個同事對象的引用。
  • Colleague（抽象同事類）：它定義各個同事類公有的方法，并聲明了一些抽象方法來供子類實現，同時它維持了一個對抽象中介者類的引用，其子類可以通過該引用來與中介者通信。
  • ConcreteColleague（具體同事類）：它是抽象同事類的子類；每一個同事對象在需要和其他同事對象通信時，先與中介者通信，通過中介者來間接完成與其他同事類的通信；在具體同事類中實現了在抽象同事類中聲明的抽象方法。

中介者模式的核心在于中介者類的引入，在中介者模式中，中介者類承擔了兩方面的職責：

  • 中轉作用（結構性）：通過中介者提供的中轉作用，各個同事對象就不再需要顯式引用其他同事，當需要和其他同事進行通信時，可通過中介者來實現間接調用。該中轉作用屬于中介者在結構上的支持。
  • 協調作用（行為性）：中介者可以更進一步的對同事之間的關系進行封裝，同事可以一致的和中介者進行交互，而不需要指明中介者需要具體怎么做，中介者根據封裝在自身內部的協調邏輯，對同事的請求進行進一步處理，將同事成員之間的關系行為進行分離和封裝。

開發(fā)中常見的場景

  • MVC模式(Controller 是中介者，根據 View 層的請求來操作 Model 層)
  • 窗口游戲程序，窗口軟件開發(fā)中窗口對象也是一個中介者對象
  • 圖形界面開發(fā)GUI中，多個組件之間的交互，可以通過引入一個中介者對象來解決，可以是整體的窗口對象或者DOM對象
  • Java.lang.reflect.Method#invoke()

數據庫同步數據案例

我們來實現一個簡化版的數據同步方案，有三種數據庫 Mysql、Redis、Elasticsearch，

  • 其中的 Mysql 作為主數據庫，當增加一條數據時需要同步到另外兩個數據庫中；
  • Redis 作為緩存數據庫，當增加一條數據時不需要同步到另外另個數據庫；
  • 而 Elasticsearch 作為大數據查詢數據庫，有一個統計功能，當增加一條數據時只需要同步到 Mysql，

所以它們之間的關系圖如下所示。

在這里插入圖片描述

不使用中介者模式的數據同步方案，各數據源維護各自的同步作業(yè)

抽象數據庫

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 的同步作業(yè)

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

在這里插入圖片描述

其實這樣已經實現了我們的需求，但是存在一些問題

  • 系統結構復雜且耦合度高。數據源需要維護目標端數據庫的引用，以便完成數據同步
  • 組件的可重用性差。由于每一個數據源和目標端之間具有很強的關聯，若沒有目標端的支持，這個組件很難被另一個系統或模塊重用
  • 系統的可擴展性差：如果需要增加、修改或刪除其中一個數據庫、將導致多個類的源代碼需要修改，這違反了“開閉原則”，可擴展性和靈活性欠佳。

中介者模式來重構，將數據同步的功能遷移到中介者中，由中介者來管理數據同步作業(yè)

抽象中介者:

//抽象中介者
@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();
    }
}

在這里插入圖片描述

小結

主要優(yōu)點

  • 中介者模式簡化了對象之間的交互，它用中介者和同事的一對多交互代替了原來同事之間的多對多交互，一對多關系更容易理解、維護和擴展，將原本難以理解的網狀結構轉換成相對簡單的星型結構。
  • 中介者模式可將各同事對象解耦。中介者有利于各同事之間的松耦合，我們可以獨立的改變和復用每一個同事和中介者，增加新的中介者和新的同事類都比較方便，更好地符合 “開閉原則”。
  • 可以減少子類生成，中介者將原本分布于多個對象間的行為集中在一起，改變這些行為只需生成新的中介者子類即可，這使各個同事類可被重用，無須對同事類進行擴展。

中介者模式的主要缺點

  • 在具體中介者類中包含了大量同事之間的交互細節(jié)，可能會導致具體中介者類非常復雜，使得系統難以維護。（也就是把具體同事類之間的交互復雜性集中到了中介者類中，結果中介者成了最復雜的類）

適用場景

  • 系統中對象之間存在復雜的引用關系，系統結構混亂且難以理解。
  • 一個對象由于引用了其他很多對象并且直接和這些對象通信，導致難以復用該對象。
  • 想通過一個中間類來封裝多個類中的行為，而又不想生成太多的子類。可以通過引入中介者類來實現，在中介者中定義對象交互的公共行為，如果需要改變行為則可以增加新的具體中介者類

具體應用

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秒后開始執(zhí)行，循環(huán)周期為 1秒

public class TimerTest {
    public static void main(String[] args) {
        // 注意：多線程并行處理定時任務時，Timer運行多個TimeTask時，只要其中之一沒有捕獲拋出的異常，
        // 其它任務便會自動終止運行，使用ScheduledExecutorService則沒有這個問題
        Timer timer = new Timer();
        timer.schedule(new MyOneTask(), 3000, 1000); // 3秒后開始運行，循環(huán)周期為 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) {
                // 判斷線程的狀態(tài),防止多線程同時調度到一個任務時多次被加入任務隊列
                if (task.state != TimerTask.VIRGIN)
                    throw new IllegalStateException(
                        "Task already scheduled or cancelled");
                // 初始化定時任務的下次執(zhí)行時間
                task.nextExecutionTime = time;
                // 重復執(zhí)行的間隔時間
                task.period = period;
                // 將定時任務的狀態(tài)由TimerTask.VIRGIN(一個定時任務的初始化狀態(tài))設置為TimerTask.SCHEDULED
                task.state = TimerTask.SCHEDULED;
            }
            // 將任務加入任務隊列
            queue.add(task);
            // 如果當前加入的任務是需要第一個被執(zhí)行的(也就是他的下一次執(zhí)行時間離現在最近)
            // 則喚醒等待queue的線程(對應到上面提到的queue.wait())
            if (queue.getMin() == task)
                queue.notify();
        }
    }
    // cancel會等到所有定時任務執(zhí)行完后立刻終止定時線程
    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 中定時調度線程類的定義，這個類會做為一個線程一直運行來執(zhí)行 Timer 中任務隊列中的任務。

Timer 這個中介者的功能就是定時調度我們寫的各種任務，將任務添加到 TaskQueue 任務隊列中，給 TimerThread 執(zhí)行，讓任務與執(zhí)行線程解耦

參考文章

設計模式之中介者模式

23種設計模式（7）：中介者模式

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注腳本之家的更多內容！

相關文章

  • SpringBoot獲取不到用戶真實IP的解決方法

    SpringBoot獲取不到用戶真實IP的解決方法

    最近遇到個問題，項目部署后發(fā)現服務端無法獲取到客戶端真實的IP地址，本文就來介紹一下這個問題的解決方法，感興趣的可以了解一下
    2023-08-08
  • Java如何實現讀取txt文件內容并生成Word文檔

    Java如何實現讀取txt文件內容并生成Word文檔

    本文主要介紹了通過Java實現讀取txt文件中的內容，并將內容生成Word文檔。文章的代碼非常詳細，具有一定的學習價值，感興趣的小伙伴可以了解一下
    2021-12-12
  • 淺談利用Spring的AbstractRoutingDataSource解決多數據源的問題

    淺談利用Spring的AbstractRoutingDataSource解決多數據源的問題

    本篇文章主要介紹了淺談利用Spring的AbstractRoutingDataSource解決多數據源的問題，具有一定的參考價值，有需要的可以了解一下
    2017-08-08
  • java文件上傳下載代碼實例

    java文件上傳下載代碼實例

    這篇文章主要介紹了java文件上傳下載，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2019-03-03
  • 詳解Spring如何更簡單的讀取和存儲對象

    詳解Spring如何更簡單的讀取和存儲對象

    這篇文章主要為大家詳細介紹了Spring中如何更簡單的實現讀取和存儲對象，文中的示例代碼講解詳細，感興趣的小伙伴可以跟隨小編一起學習一下
    2023-07-07
  • 重新認識Java的System.in

    重新認識Java的System.in

    今天小編就為大家分享一篇關于重新認識Java的System.in，小編覺得內容挺不錯的，現在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧
    2018-12-12
  • spring中的注入list集合

    spring中的注入list集合

    這篇文章主要介紹了spring中的注入list集合問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2022-11-11
  • java 獲取服務器真實IP的實例

    java 獲取服務器真實IP的實例

    這篇文章主要介紹了java 獲取服務器真實IP的實例的相關資料,這里提供實現方法幫助大家學習理解這部分內容，需要的朋友可以參考下
    2017-08-08
  • SpringBoot創(chuàng)建RSocket服務器的全過程記錄

    SpringBoot創(chuàng)建RSocket服務器的全過程記錄

    RSocket應用層協議支持 Reactive Streams語義， 例如：用RSocket作為HTTP的一種替代方案。這篇文章主要給大家介紹了關于SpringBoot創(chuàng)建RSocket服務器的相關資料,需要的朋友可以參考下
    2021-05-05
  • Java list與set中contains()方法效率案例詳解

    Java list與set中contains()方法效率案例詳解

    這篇文章主要介紹了Java list與set中contains()方法效率案例詳解,本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內容,需要的朋友可以參考下
    2021-08-08

最新評論