1. 程式人生 > >設計模式——行為型——中介者模式

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

定義:用一箇中介者物件封裝一系列的物件互動,中介者使各物件不需要顯示地相互作用,從而使耦合鬆散,而且可以獨立地改變它們之間的互動。

型別:行為類模式

類圖:

中介者模式的結構

       中介者模式又稱為調停者模式,從類圖中看,共分為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());  
          
    }  
}  

雖然程式碼比較長,但是還是比較容易理解的,其實就是把原來處理物件關係的程式碼重新封裝到一箇中介類中,通過這個中介類來處理物件間的關係。

中介者模式的優點

  • 適當地使用中介者模式可以避免同事類之間的過度耦合,使得各同事類之間可以相對獨立地使用。
  • 使用中介者模式可以將物件間一對多的關聯轉變為一對一的關聯,使物件間的關係易於理解和維護。
  • 使用中介者模式可以將物件的行為和協作進行抽象,能夠比較靈活的處理物件間的相互作用。

適用場景

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

       中介者模式是一種比較常用的模式,也是一種比較容易被濫用的模式。對於大多數的情況,同事類之間的關係不會複雜到混亂不堪的網狀結構,因此,大多數情況下,將物件間的依賴關係封裝的同事類內部就可以的,沒有必要非引入中介者模式。濫用中介者模式,只會讓事情變的更復雜。

轉:https://blog.csdn.net/chenhuade85/article/details/8141831