設計模式——中介者模式

文章目錄

• 定義
• 結構
• 為什麼要使用中介者模式
• 優點
• 使用場景

定義

用一個中介者對象封裝一系列的對象互動，中介者使各對象不需要顯示地互相作用，進而使耦合松散，而且可以獨立地改變它們之間的互動。

類型：行為類模式

類圖：

結構

中介者模式又稱為調停者模式，從類圖中看，共分為3部分：

• 抽象中介者：定義好同僚類對象到中介者對象的接口，用于各個同僚類之間的通信。一般包括一個或幾個抽象的事件方法，并由子類去實作。
• 中介者實作類：從抽象中介者繼承而來，實作抽象中介者中定義的事件方法。從一個同僚類接收消息，然後通過消息影響其他同時類。
• 同僚類：如果一個對象會影響其他的對象，同時也會被其他對象影響，那麼這兩個對象稱為同僚類。在類圖中，同僚類隻有一個，這其實是現實的省略，在實際應用中，同僚類一般由多個組成，他們之間互相影響，互相依賴。同僚類越多，關系越複雜。并且，同僚類也可以表現為繼承了同一個抽象類的一組實作組成。在中介者模式中，同僚類之間必須通過中介者才能進行消息傳遞。

為什麼要使用中介者模式

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

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

我們使用一個例子來說明一下什麼是同僚類：有兩個類A和B，類中各有一個數字，并且要保證類B中的數字永遠是類A中數字的100倍。也就是說，當修改類A的數時，将這個數字乘以100賦給類B，而修改類B時，要将數除以100賦給類A。類A類B互相影響，就稱為同僚類。代碼如下：

abstract class AbstractColleague {
        protected int number;

        public int getNumber() {
            return number;
        }

        public void setNumber(int number){
            this.number = number;
        }
        //抽象方法，修改數字時同時修改關聯對象
        public abstract void setNumber(int number, AbstractColleague coll);
    }

    class ColleagueA extends AbstractColleague{
        public void setNumber(int number, AbstractColleague coll) {
            this.number = number;
            coll.setNumber(number*100);
        }
    }

    class ColleagueB extends AbstractColleague{

        public void setNumber(int number, AbstractColleague coll) {
            this.number = number;
            coll.setNumber(number/100);
        }
    }

    public class Client {
        public static void main(String[] args){

            AbstractColleague collA = new ColleagueA();
            AbstractColleague collB = new ColleagueB();

            System.out.println("==========設定A影響B==========");
            collA.setNumber(1288, collB);
            System.out.println("collA的number值："+collA.getNumber());
            System.out.println("collB的number值："+collB.getNumber());

            System.out.println("==========設定B影響A==========");
            collB.setNumber(87635, collA);
            System.out.println("collB的number值："+collB.getNumber());
            System.out.println("collA的number值："+collA.getNumber());
        }
    }
           

上面的代碼中，類A類B通過直接的關聯發生關系，假如我們要使用中介者模式，類A類B之間則不可以直接關聯，他們之間必須要通過一個中介者來達到關聯的目的。

abstract class AbstractColleague {
        protected int number;

        public int getNumber() {
            return number;
        }

        public void setNumber(int number){
            this.number = number;
        }
        //注意這裡的參數不再是同僚類，而是一個中介者
        public abstract void setNumber(int number, AbstractMediator am);
    }

    class ColleagueA extends AbstractColleague{

        public void setNumber(int number, AbstractMediator am) {
            this.number = number;
            am.AaffectB();
        }
    }

    class ColleagueB extends AbstractColleague{

        @Override
        public void setNumber(int number, AbstractMediator am) {
            this.number = number;
            am.BaffectA();
        }
    }

    abstract class AbstractMediator {
        protected AbstractColleague A;
        protected AbstractColleague B;

        public AbstractMediator(AbstractColleague a, AbstractColleague b) {
            A = a;
            B = b;
        }

        public abstract void AaffectB();

        public abstract void BaffectA();

    }
    class Mediator extends AbstractMediator {

        public Mediator(AbstractColleague a, AbstractColleague b) {
            super(a, b);
        }

        //處理A對B的影響
        public void AaffectB() {
            int number = A.getNumber();
            B.setNumber(number*100);
        }

        //處理B對A的影響
        public void BaffectA() {
            int number = B.getNumber();
            A.setNumber(number/100);
        }
    }

    public class Client {
        public static void main(String[] args){
            AbstractColleague collA = new ColleagueA();
            AbstractColleague collB = new ColleagueB();

            AbstractMediator am = new Mediator(collA, collB);

            System.out.println("==========通過設定A影響B==========");
            collA.setNumber(1000, am);
            System.out.println("collA的number值為："+collA.getNumber());
            System.out.println("collB的number值為A的10倍："+collB.getNumber());

            System.out.println("==========通過設定B影響A==========");
            collB.setNumber(1000, am);
            System.out.println("collB的number值為："+collB.getNumber());
            System.out.println("collA的number值為B的0.1倍："+collA.getNumber());

        }
    }
           

雖然代碼比較長，但是還是比較容易了解的，其實就是把原來處理對象關系的代碼重新封裝到一個中介類中，通過這個中介類來處理對象間的關系。

優點

• 适當地使用中介者模式可以避免同僚類之間的過度耦合，使得各同僚類之間可以相對獨立地使用。
• 使用中介者模式可以将對象間一對多的關聯轉變為一對一的關聯，使對象間的關系易于了解和維護。
• 使用中介者模式可以将對象的行為和協作進行抽象，能夠比較靈活的處理對象間的互相作用。

使用場景

在面向對象程式設計中，一個類必然會與其他的類發生依賴關系，完全獨立的類是沒有意義的。一個類同時依賴多個類的情況也相當普遍，既然存在這樣的情況，說明，一對多的依賴關系有它的合理性，适當的使用中介者模式可以使原本淩亂的對象關系清晰，但是如果濫用，則可能會帶來反的效果。一般來說，隻有對于那種同僚類之間是網狀結構的關系，才會考慮使用中介者模式。可以将網狀結構變為星狀結構，使同僚類之間的關系變的清晰一些。

中介者模式是一種比較常用的模式，也是一種比較容易被濫用的模式。對于大多數的情況，同僚類之間的關系不會複雜到混亂不堪的網狀結構，是以，大多數情況下，将對象間的依賴關系封裝的同僚類内部就可以的，沒有必要非引入中介者模式。濫用中介者模式，隻會讓事情變的更複雜。