Java設計模式系列之中介者模式

中介者模式(Mediator)的定義

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

中介者模式(Mediator)的適用性

1.一組對象以定義良好但是復雜的方式進行通信，產生的相互依賴關系結構混亂且難以理解。

2.一個對象引用其他很多對象並且直接與這些對象通信,導致難以復用該對象。

3.想定制一個分布在多個類中的行為，但又不想生成太多的子類。

中介者模式(Mediator)的參與者

1.Mediator

中介者定義一個接口用於與各同事（Colleague）對象通信。

2.ConcreteMediator

具體中介者通過協調各同事對象實現協作行為，了解並維護它的各個同事。

3.Colleague:

抽象同事類。

４.Colleagueclass

具體同事類。每個具體同事類都只需要知道自己的行為即可，但是他們都需要認識中介者

中介者模式的UML類圖

　　　　　　　　　　　　　　　　

具體代碼實現：

第一步：定義Mediator

//定義抽象Mediator,可以與同時們進行聯絡
 public abstract class Mediator {
     public abstract void contact(String content,Colleague coll);
 }

 第二步：定義抽象Colleague

public class Colleague {
    protected String name;
    protected Mediator mediator;

    public Colleague(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }
}

 第三步：定義具體Colleagueclass

public class ColleagueA extends Colleague {

    // 具體同事類繼承自Colleague,此刻就可以與中介者mediator進行通信了
    public ColleagueA(String name, Mediator mediator) {
        super(name, mediator);
    }
    public void getMessage(String message){
        System.out.println("同事A"+name+"獲得信息"+message);
    }
    //同事A與中介者通信
    public void contact(String message){
        mediator.contact(message, this);
    }
}
public class ColleagueB extends Colleague {

    public ColleagueB(String name, Mediator mediator) {
        super(name, mediator);
    }
    public void getMessage(String message){
        System.out.println("同事B"+name+"獲得信息"+message);
    }
    //同事B與中介者通信
    public void contact(String message){
        mediator.contact(message, this);
    }
}

第四步：定義具體中介者ConcreteMediator,具體中介者通過協調各同事對象實現協作行為，了解並維護它的各個同事。

//定義具體中介者ConcreteMediator,具體中介者通過協調各同事對象實現協作行為，了解並維護它的各個同事。
public class ConcreteMediator extends Mediator {
    ColleagueA collA;
    ColleagueB collB;

    public ColleagueA getCollA() {
        return collA;
    }

    public void setCollA(ColleagueA collA) {
        this.collA = collA;
    }

    public ColleagueB getCollB() {
        return collB;
    }

    public void setCollB(ColleagueB collB) {
        this.collB = collB;
    }

    @Override
    public void contact(String content, Colleague coll) {
        if (coll==collA) {
            collB.getMessage(content);
        } else {
            collA.getMessage(content);
        }
    }
}

第五步：定義Client，測試中介者模式的使用

public class Client {

    /**
     * @param args
     */
    // 中介者，ColleagueA、ColleagueB
    public static void main(String[] args) {
        // 定義中介者
        ConcreteMediator mediator = new ConcreteMediator();
        // 定義具體同事類
        ColleagueA colleagueA = new ColleagueA("張三", mediator);
        ColleagueB colleagueB = new ColleagueB("李四", mediator);
        // 中介者知曉每一個具體的Colleague類
        mediator.setCollA(colleagueA);
        mediator.setCollB(colleagueB);
        colleagueA.contact("我是A，我要和同事B說說工作的事情");
        colleagueB.contact("我是B,我下午有時間,下午商量吧");
    }

}

運行結果:

同事B李四獲得信息:我是A，我要和同事B說說工作的事情
同事A張三獲得信息:我是B,我下午有時間,下午商量吧

總結：
中介者就是一個處於眾多對象中間，並恰當地處理眾多對象之間相互之間的聯系的角色。以上代碼中只有兩個參與者類，但是這些我們都可以根據中介者模式的宗旨進行適當地擴展，即增加參與者類，然后中介者就得擔負更加重的任務了，我們看到上面具體中介者類Mediator中的方法比較多而且有點亂。 所以，在解耦參與者類之間的聯系的同時，中介者自身也不免任務過重，因為幾乎所有的業務邏輯都交代到中介者身上了，可謂是“萬眾期待”的一個角色了。這就是中介者模式的不足之處了。此外，上面這個代碼例子的參與者的屬性和方法都是一樣的，我們可以抽取一個抽象類出來，減少代碼，但是有時候我們根本抽取不了多個“參與者”之間的共性來形成一個抽象類，這也大大增加了中介者模式的使用難度。