2. 程式人生 > >JAVA的23種設計模式---中介者模式

JAVA的23種設計模式---中介者模式

阿新 • • 發佈：2019-02-12

概要：

該文章參考了《設計模式之禪》一書及一些前輩的部落格文章

1.該文章闡述了中介者模式的基礎原理及示例程式碼；
2.該文章適合初學設計模式的技術人員研習；
3.該文章有許多不足之處，請各位大咖指正，噴子繞道；

正文：

中介者模式：用一箇中介物件封裝一系列的物件互動，中介者使各物件不需要顯示地相互作用，從而使其耦合鬆散，而且可以獨立的改變他們之間的互動

1.中介者模式示例程式碼實現：

package com.csdn;
/**
 * 抽象中介者
 * @author Administrator
 *
 */
public abstract class AbstractMediator
 
 {
    //魏國
    protected Wei wei;
    //蜀國
    protected Shu shu;
    //吳國
    protected Wu wu;
    //構造器初始化三國
    public AbstractMediator(){
        this.wei = new Wei(this);
        this.shu = new Shu(this);
        this.wu = new Wu(this);
    }
    //最重要的事件方法，處理多個物件之間的關係
    public abstract void execute(String string,Object...objects) throws
 
 Exception;

}
package com.csdn;

import java.lang.reflect.Field;
/**
 * 具體中介者
 * @author Administrator
 *
 */
public class Mediator extends AbstractMediator{
    //中介者最重要的方法，處理各方關係
    @Override
    public void execute(String string, Object... objects) throws Exception {
        //魏國請求和平
        if(string.equalsIgnoreCase("weiForPeace"
 
)){
            this.weiForPeace();
        //蜀國請求和平
        }else if(string.equalsIgnoreCase("shuForPeace")){
            this.shuForPeace();
        //吳國請求和平
        }else if(string.equalsIgnoreCase("wuForPeace")) {
            this.wuForPeace();
        //魏國實力增長導致另外兩國實力下降
        }else if(string.equalsIgnoreCase("weiIncrease")){
            this.weiIncrease();
        //蜀國實力增長導致另外兩國實力下降
        }else if(string.equalsIgnoreCase("shuIncrease")){
            this.shuIncrease();
        //吳國實力增長導致另外兩國實力下降
        }else if(string.equalsIgnoreCase("wuIncrease")){
            this.wuIncrease();
        }               
    }
    //吳國實力增長導致另外兩國實力下降執行方法
    private void wuIncrease() {
        super.wei.decrease();
        super.shu.decrease();   
    }
    //蜀國實力增長導致另外兩國實力下降執行方法
    private void shuIncrease() {
        super.wei.decrease();
        super.wu.decrease();    
    }
    //魏國實力增長導致另外兩國實力下降執行方法
    private void weiIncrease() {
        super.shu.decrease();
        super.wu.decrease();
    }
    //魏國請求和平，三國實力重置
    private void weiForPeace() throws Exception {
        System.out.println("魏國求和，三國實力重置！");
        System.out.println("魏國實力恢復成功！"+"實力為:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀國實力恢復成功！"+"實力為:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吳國實力恢復成功！"+"實力為:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //蜀國請求和平，三國實力重置
    private void shuForPeace() throws Exception {
        System.out.println("蜀國求和，三國實力重置！");
        System.out.println("魏國實力恢復成功！"+"實力為:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀國實力恢復成功！"+"實力為:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吳國實力恢復成功！"+"實力為:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //吳國請求和平，三國實力重置
    private void wuForPeace() throws Exception {
        System.out.println("吳國求和，三國實力重置！");
        System.out.println("魏國實力恢復成功！"+"實力為:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀國實力恢復成功！"+"實力為:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吳國實力恢復成功！"+"實力為:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //通過反射，重置三國實力具體方法
    public int recovery(Class clazz,String string) throws Exception{
        Field fieldWei = clazz.getDeclaredField(string);
        fieldWei.setAccessible(true);
        fieldWei.setInt(string, 10);        
        return fieldWei.getInt(string);
    }
}
package com.csdn;
/**
 * 抽象同事類，每個國家都需實現
 * @author Administrator
 *
 */
public abstract class AbstractColleague {
    //中介者
    protected AbstractMediator mediator;
    //構造器初始化中介者
    public AbstractColleague(AbstractMediator _mediator){
        this.mediator = _mediator;
    }   
    //三個國家需要實現的方法
    public abstract void increase() throws Exception;
    public abstract void decrease();
    public abstract void getStrength();
    public abstract void reset() throws Exception;
}
package com.csdn;
/**
 * 魏國
 * @author Administrator
 *
 */
public class Wei extends AbstractColleague{
    //將魏國和中介者連結
    public Wei(AbstractMediator _mediator) {
        super(_mediator);
    }
    //魏國實力
    private static int WEI_STRENGTH = 10;
    //魏國實力增長
    @Override
    public void increase() throws Exception{
        WEI_STRENGTH += 1;
        System.out.println("魏國實力增長到:"+WEI_STRENGTH);
        super.mediator.execute("weiIncrease");
    }
    //魏國實力下降
    @Override
    public void decrease(){
        WEI_STRENGTH -= 1;
        System.out.println("魏國實力減弱到:"+WEI_STRENGTH);
    }
    //顯示魏國實力
    @Override
    public void getStrength(){
        System.out.println("魏國實力為："+WEI_STRENGTH);
    }
    //魏國求和
    @Override
    public void reset() throws Exception{
        System.out.println("魏國實力為："+WEI_STRENGTH);
        super.mediator.execute("weiForPeace");
    }
}
package com.csdn;
/**
 * 蜀國
 * @author Administrator
 *
 */
public class Shu extends AbstractColleague{
    //將蜀國和中介者連結
    public Shu(AbstractMediator _mediator) {
        super(_mediator);
    }
    //蜀國實力
    private static int SHU_STRENGTH = 10;
    //蜀國實力增長
    @Override
    public void increase() throws Exception{
        SHU_STRENGTH += 1;
        System.out.println("蜀國實力增長到:"+SHU_STRENGTH);
        super.mediator.execute("shuIncrease");
    }
    //蜀國實力下降
    @Override
    public void decrease(){
        SHU_STRENGTH -= 1;
        System.out.println("蜀國實力減弱到:"+SHU_STRENGTH);
    }
    //顯示蜀國實力
    @Override
    public void getStrength(){
        System.out.println("蜀國實力為："+SHU_STRENGTH);
    }
    //蜀國求和
    @Override
    public void reset() throws Exception{
        System.out.println("蜀國實力為："+SHU_STRENGTH);
        super.mediator.execute("shuForPeace");
    }
}
package com.csdn;
/**
 * 吳國
 * @author Administrator
 *
 */
public class Wu extends AbstractColleague{
    //將吳國和中介者連結
    public Wu(AbstractMediator _mediator) {
        super(_mediator);
        // TODO Auto-generated constructor stub
    }
    //吳國實力
    private static int WU_STRENGTH = 10;
    //吳國實力增長
    @Override
    public void increase() throws Exception{
        WU_STRENGTH += 1;
        System.out.println("吳國實力增長到:"+WU_STRENGTH);
        super.mediator.execute("wuIncrease");
    }
    //吳國實力下降
    @Override
    public void decrease(){
        WU_STRENGTH -= 1;
        System.out.println("吳國實力減弱到:"+WU_STRENGTH);
    }
    //顯示吳國實力
    @Override
    public void getStrength(){
        System.out.println("吳國實力為："+WU_STRENGTH);
    }
    //吳國求和
    @Override
    public void reset() throws Exception{
        System.out.println("吳國實力為："+WU_STRENGTH);
        super.mediator.execute("wuForPeace");
    }
}
package com.csdn;
/**
 * 模擬戰場
 * @author Administrator
 *
 */
public class Battlefield {
    public static void main(String[] args) throws Exception{
        //建立中介者及三國實體物件
        AbstractMediator mediator = new Mediator();
        Wei wei = new Wei(mediator);
        Shu shu = new Shu(mediator);
        Wu wu = new Wu(mediator);
        /*輸出：
        魏國實力增長到:11
        蜀國實力減弱到:9
        吳國實力減弱到:9*/
        wei.increase();
        /*輸出：
        吳國實力增長到:10
        魏國實力減弱到:10
        蜀國實力減弱到:8*/
        wu.increase();
        /*輸出：
        蜀國實力為：8
        蜀國求和，三國實力重置！
        魏國實力恢復成功！實力為:10
        蜀國實力恢復成功！實力為:10
        吳國實力恢復成功！實力為:10*/
        shu.reset();
        /*輸出：
        蜀國實力增長到:11
        魏國實力減弱到:9
        吳國實力減弱到:9*/
        shu.increase();     
    }
}

注：
a：該示例在程式碼實現方面還可以進行部分優化
b：同事類必須有中介者，而中介者可以只有部分同事類
c：同事類的行為分為兩種，一種是同事本身的行為，用來改變自身狀態，處理自身行為，與其他的同事類和中介者沒有任何依賴，這種行為叫自發行為。還有一種是必須依賴中介者才能完成的行為，叫依賴方法
d：通常中介者模式中的同事類是協作關係，處理不同的業務。如果兩個物件不能提煉出共性，那就不要去刻意追求兩者的抽象，抽象只要去定義出模式需要的角色即可，根據專案實際情況而定（本示例為了展示的更加清晰，在同事類業務區分這方面可能不太恰當，三國相比於是同事類可能更像兄弟類）

2.中介者模式通用模型程式碼實現：

package com.csdn;
/**
 * 通用抽象中介者
 * @author Administrator
 *
 */
public abstract class Mediator {
    //定義同事類
    protected ConcreteColleague1 c1;
    protected ConcreteColleague2 c2;
    //通過getter/setter方法把同事類注入過來
    public ConcreteColleague1 getC1() {
        return c1;
    }
    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }
    public ConcreteColleague2 getC2() {
        return c2;
    }
    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }
    //中介者模式的業務邏輯
    public abstract void doSomething1();
    public abstract void doSomething2();
}
package com.csdn;
/**
 * 通用中介者
 * @author Administrator
 *
 */
public class ConcreteMediator extends Mediator{
    @Override
    public void doSomething1() {
        //呼叫同事類的方法，只要是public的都可以呼叫
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
    @Override
    public void doSomething2() {
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
}
package com.csdn;
/**
 * 抽象同事類
 * @author Administrator
 *
 */
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator _mediator){
        this.mediator = _mediator;
    }
}
package com.csdn;
/**
 * 具體同事類
 * @author Administrator
 *
 */
public class ConcreteColleague1 extends Colleague{
    //通過建構函式傳遞給中介者
    public ConcreteColleague1(Mediator _mediator) {
        super(_mediator);
    }
    public void selfMethod1(){
        //自己的業務邏輯
    }
    public void depMethod1(){
        //自己的業務邏輯
        //自己處理不了的業務邏輯，給中介者處理
        super.mediator.doSomething1();
    }
}
package com.csdn;
/**
 * 具體同事類
 * @author Administrator
 *
 */
public class ConcreteColleague2 extends Colleague{
    //通過建構函式傳遞給中介者
    public ConcreteColleague2(Mediator _mediator) {
        super(_mediator);
    }
    public void selfMethod2(){
        //自己的業務邏輯
    }
    public void depMethod2(){
        //自己的業務邏輯
        //自己處理不了的業務邏輯，給中介者處理
        super.mediator.doSomething2();
    }
}

相關推薦

java23種設計模式-中介者模式

定義 用一箇中介物件來封裝一系列的物件互動，中介者使各物件不需要顯式地相互引用，從而使其耦合鬆散，而且可以獨立地改變它們之間的互動。 角色 Colleague：是一個抽象類或者介面，提供和其他Colleague通訊的方法 notify(String nam

23種設計模式--中介者模式-Mediator Pattern

ole 缺點 業務 -m ram -- 成了 ons 錯誤 一、中介者模式的介紹 中介者模式第一下想到的就是中介，房子中介，婚姻中介啊等等，當然筆者也希望來個婚姻中介給我介紹一個哈哈哈，，回歸正題中介者模式分成中介者類和用戶類，根據接口編程的方式我們再把中介和用戶類

JAVA的23種設計模式---中介者模式

概要： 該文章參考了《設計模式之禪》一書及一些前輩的部落格文章 1.該文章闡述了中介者模式的基礎原理及示例程式碼； 2.該文章適合初學設計模式的技術人員研習； 3.該文章有許多不足之處，請各位大咖指正，噴子繞道； 正文： 中介者模式：用一箇中介物

設計模式——中介者模式/調停者模式（C++實現）

con 分享 else .cn sign name 得到 ted esp 1 #include <iostream> 2 #include <string> 3 4 using namespace std;

大話設計模式—中介者模式

java string word 實例 發生 scrip ron 成了 維護 中介者模式（Mediator Pattern）是用來減少多個對象和類之間的通信復雜性。這種模式提供了一個中介類，該類通常處理不同類之間的通信，並支持松耦合。使代碼易於維護。中介

設計模式------中介者模式

而且 作用 dos some 自己的 eth pan 沒有 self 中介者模式定義 用一個中介對象封裝一系列的對象交互，中介者使各對象不需要顯示地相互作用，從而使其耦合松散，而且可以獨立地改變它們之間的交互。 Mediator抽象中介者角色 抽象中介者角色定義統一的接

設計模式——中介者模式

解耦 用戶名 進行 edi 目標 tac visitor 適用場景 行為 中介者模式定義 中介者對象封裝系列的對象交互，中介者使得對象不需要顯示地相互作用，從而松耦合，能夠獨立改變它們之間的交互。 中介者模式角色 抽象中介者： 用於各個同事類之間的通信，同事類對象到中介者

設計模式-中介者模式

設計模式 中介者模式 場景：服務端與客戶端通過webSocket方式通話，websocket充當中介 abstract class TongXinObject { protected Agency agency; public TongXinO

用心理解設計模式——中介者模式 / 調停者模式 (Mediator Pattern)

前置文章： 用心理解設計模式——設計模式的原則  設計模式相關程式碼已統一放至 我的 Github   一、定義   行為型模式之一。 Define an object that encapsulates how a set of obje

設計模式 --- 中介者模式

1.定義 中介者模式包裝了一系列物件相互作用方式，使得這些物件不必相互明顯作用。從而使他們可以鬆耦合。當某些物件之間作用發生改變的時候，不會立即影響其他的一些物件之間的作用。保證這些作用可以彼此獨立變化。中介者模式將多對多的相互作用轉化為一對多的相互作用。中介者模式將物件的行為和協作抽象化，把物

設計模式-行為型模式-中介者模式

設計模式-行為型模式-中介者模式 行為型模式 劃分類和物件的職責。 中介者模式 進銷存管理，即採購，銷售，庫存。 其中類圖 程式碼如下 public class Purchase { // 採購IBM電腦 public void buyIBMcomputer(int numb

設計模式-中介者模式（Mediator）

中介者模式是行為型模式的一種，在Mediator中，類之間的互動行為被統一放在Mediator物件中，物件通過Mediator物件同其他物件互動。 角色和職責： 1.中介者介面（Mediator）:    中介者類的抽象父類 2.具體中介者（Concrete Mediator） -

設計模式 | 中介者模式及典型應用

本文的主要內容： 介紹中介者模式 資料同步示例 中介者模式總結 原始碼分析中介者模式的典型應用 Java Timer 中的中介者模式 中介者模式 世界上存在著各種各樣的資料庫，不同資料庫有各自的應用場景，對於同一份資料，最開始可能使用關係型資料庫（如M

移動開發之設計模式- 中介者模式(IOS&Android)

資源 完全參照 直譯器模式|菜鳥教程但不包括IOS程式碼 中介者模式 中介者模式（Mediator Pattern）是用來降低多個物件和類之間的通訊複雜性。這種模式提供了一箇中介類，該類通常處理不同類之間的通訊，並支援鬆耦合，使程式碼易於維護。中介者模式屬於行為型模式。 介紹

“戲”說設計模式——中介者模式

首先請出今天的主人公——“丐幫幫主”喬峰  蕭峰一生有情有義，對愛情堅貞，對國家和民族忠誠，人生經歷坎坷悲壯，其胸襟氣吞山河，他提倡人道和平，選擇為拯救世人而自我毀滅，是一個心繫蒼生、悲天憫人、思想境界超越國界和民族的悲劇英雄。 中介者模式簡介： 中介是作用於多個事物

設計模式- 中介者模式

中介者模式 在我們做遊戲的時候，我們會把整體分為幾個系統，如戰鬥系統，介面系統等等。在類的數量比較小的時候，我們只需要相互呼叫就可以輕鬆的解決問題。但是當類的數量變多了之後，類之間相互依賴相互呼叫的話，首先破壞了單一職責原則。 單一系統引入太多其他系統的功能，不易於維護。若要是被太多其他系統

設計模式--中介者模式

中介者模式（Mediator Pattern） 中介者模式是用來降低多個物件和類之間的通訊複雜性。這種模式提供了一箇中介類，該類通常處理不同類之間的通訊，並支援鬆耦合，使程式碼易於維護。中介者模式屬於行為型模式。 介紹 意圖：用一箇中介物件來封裝一系列

15-Python與設計模式--中介者模式

一、倉儲管理系統 有一個手機倉儲管理系統，使用者有三方：銷售、倉庫管理員、採購。需求是：銷售一旦達成訂單，銷售人員會通過系統的銷售子系統部分通知倉儲子系統，倉儲子系統會將可出倉手機數量減少，同時通知採購管理子系統當前銷售訂單；倉儲子系統的庫存到達閾值以下，會通知銷售子系統和採購子系統，並督促採購子系統採購；

C++設計模式——中介者模式

前言    在沒有引入星形網路拓撲圖之前，計算機之間可以直接通訊，但如果某臺計算機要和其它多臺計算機進行通訊，則這臺計算機必須認識所要進行通訊的其餘計算機。計算機與計算機之間存在多對多的關係，導致計算機之間關係非常複雜。引入星形網路拓撲圖之後，計算機之間不再直接進行通訊，而

中介者模式+遊戲開發中的設計模式——中介者模式

siki學院學習筆記——中介者模式 設計模式之中介者模式（Mediator） http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/30/2663922.html 何為中介者模式 中介者模式(Mediator):用一箇中介物件來封裝