中介者模式
- 引言
- 介紹
- 角色
- 開發中常見的場景
- 資料庫同步資料案例
- 不使用中介者模式的資料同步方案，各資料源維護各自的同步作業
- 其實這樣已經實作了我們的需求，但是存在一些問題
- 中介者模式來重構，將資料同步的功能遷移到中介者中，由中介者來管理資料同步作業
- 總結
- 主要優點
- 中介者模式的主要缺點
- 適用場景
- 具體應用
- Java Timer 中的中介者模式
- 參考文章
引言
一般來說，同事類之間的關系是比較復雜的，多個同事類之間互相關聯時，他們之間的關系會呈現為復雜的網狀結構，這是一種過度耦合的架構，即不利于類的復用，也不穩定，例如在下圖中，有六個同事類物件，假如物件1發生變化，那么將會有4個物件受到影響，如果物件2發生變化，那么將會有5個物件受到影響，也就是說，同事類之間直接關聯的設計是不好的，
如果引入中介者模式，那么同事類之間的關系將變為星型結構，從圖中可以看到，任何一個類的變動，只會影響的類本身，以及中介者，這樣就減小了系統的耦合，一個好的設計，必定不會把所有的物件關系處理邏輯封裝在本類中，而是使用一個專門的類來管理那些不屬于自己的行為，
介紹
中介者模式(Mediator Pattern)：用一個中介物件（中介者）來封裝一系列的物件互動，中介者使各物件不需要顯式地相互參考，從而使其耦合松散，而且可以獨立地改變它們之間的互動，中介者模式又稱為調停者模式，它是一種物件行為型模式，
角色
-
Mediator（抽象中介者）：它定義一個介面，該介面用于與各同事物件之間進行通信， -
ConcreteMediator（具體中介者）：它是抽象中介者的子類，通過協調各個同事物件來實作協作行為，它維持了對各個同事物件的參考， -
Colleague（抽象同事類）：它定義各個同事類公有的方法，并宣告了一些抽象方法來供子類實作，同時它維持了一個對抽象中介者類的參考，其子類可以通過該參考來與中介者通信， -
ConcreteColleague（具體同事類）：它是抽象同事類的子類；每一個同事物件在需要和其他同事物件通信時，先與中介者通信，通過中介者來間接完成與其他同事類的通信；在具體同事類中實作了在抽象同事類中宣告的抽象方法，
中介者模式的核心在于中介者類的引入，在中介者模式中，中介者類承擔了兩方面的職責：
中轉作用（結構性）：通過中介者提供的中轉作用，各個同事物件就不再需要顯式參考其他同事，當需要和其他同事進行通信時，可通過中介者來實作間接呼叫，該中轉作用屬于中介者在結構上的支持，協調作用（行為性）：中介者可以更進一步的對同事之間的關系進行封裝，同事可以一致的和中介者進行互動，而不需要指明中介者需要具體怎么做，中介者根據封裝在自身內部的協調邏輯，對同事的請求進行進一步處理，將同事成員之間的關系行為進行分離和封裝，
開發中常見的場景
- MVC模式(Controller 是中介者，根據 View 層的請求來操作 Model 層)
- 視窗游戲程式，視窗軟體開發中視窗物件也是一個中介者物件
- 圖形界面開發GUI中，多個組件之間的互動，可以通過引入一個中介者物件來解決，可以是整體的視窗物件或者DOM物件
- Java.lang.reflect.Method#invoke()
資料庫同步資料案例
我們來實作一個簡化版的資料同步方案，有三種資料庫 Mysql、Redis、Elasticsearch，
其中的 Mysql 作為主資料庫，當增加一條資料時需要同步到另外兩個資料庫中；
Redis 作為快取資料庫，當增加一條資料時不需要同步到另外另個資料庫；
而 Elasticsearch 作為大資料查詢資料庫，有一個統計功能，當增加一條資料時只需要同步到 Mysql，
所以它們之間的關系圖如下所示，
不使用中介者模式的資料同步方案，各資料源維護各自的同步作業
抽象資料庫
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 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://www.uj5u.com/qita/299264.html
標籤：其他