設計模式（十五）中介者模式

版權聲明：轉載必須註明本文轉自曉_晨的博客：http://blog.csdn.net/niunai112

目錄

導航

設計模式之六大設計原則
設計模式（一）單例模式
設計模式（二）工廠模式
設計模式（三）策略模式
設計模式（四）適配器模式
設計模式（五）享元模式
設計模式（六）建造者模式
設計模式（七）原型模式
設計模式（八）橋接模式
設計模式（九）外觀模式
設計模式（十）組合模式
設計模式（十一）裝飾器模式
設計模式（十二）代理模式
設計模式（十三）迭代器模式
設計模式（十四）觀察者模式
設計模式（十五）中介者模式
設計模式（十六）命令模式
設計模式（十七）狀態模式
設計模式（十八）訪問者模式
設計模式（十九）責任鏈模式
設計模式（二十）解釋器模式
設計模式（二十一）備忘錄模式
設計模式（二十二）模板模式
設計模式總結篇（爲什麼要學習設計模式，學習設計模式的好處）

前言

當類與類之間的依賴關係非常複雜，猶如一張錯綜複雜的網絡時，我們可以用中介者模式來解耦其中錯綜複雜的關係。

例子

UML圖

中介者模式通用代碼

/
 *
 *@Author ChenjunWang
 *@Description:中介者抽象類
 *@Date: Created in 10:51 2018/4/12
 *@Modified By:
 *
 */
public abstract class Mediator {

    protected Colleague colleagueA;
    protected Colleague colleagueB;

    public Mediator(Colleague colleagueA, Colleague colleagueB) {
        this.colleagueA = colleagueA;
        this.colleagueB = colleagueB;
    }

    public abstract void notifyColleagueA();
    public abstract void notifyColleagueB();
}

    /***
     *
     *@Author ChenjunWang
     *@Description:同事抽象類
     *@Date: Created in 10:54 2018/4/12
     *@Modified By:
     *
     */
    public abstract  class Colleague {
        protected Mediator mediator;
        public void setMediator(Mediator mediator) {
            this.mediator = mediator;
        }
        public abstract void operation();
    }
    /***
 *
 *@Author ChenjunWang
 *@Description:同事A實現類
 *@Date: Created in 10:56 2018/4/12
 *@Modified By:
 *
 */
public class ConcreteColleagueA extends Colleague {

    public void notifyColleagueB() {
        mediator.notifyColleagueB();
    }

    @Override
    public void operation() {
        System.out.println("同事A的操作");
    }
}

/***
 *
 *@Author ChenjunWang
 *@Description:同事B實現類
 *@Date: Created in 10:56 2018/4/12
 *@Modified By:
 *
 */
public class ConcreteColleagueB extends Colleague {
    public void notifyColleagueA() {
        mediator.notifyColleagueA();
    }

    @Override
    public void operation() {
        System.out.println("同事B的操作");
    }
}


/***
 *
 *@Author ChenjunWang
 *@Description:中介者具體實現類
 *@Date: Created in 10:57 2018/4/12
 *@Modified By:
 *
 */
public class ConcreteMediator extends Mediator {
    public ConcreteMediator(Colleague colleagueA, Colleague colleagueB) {
        super(colleagueA, colleagueB);
    }

    @Override
    public void notifyColleagueA() {
        if (colleagueA != null) {
            colleagueA.operation();
        }

    }

    @Override
    public void notifyColleagueB() {
        if (colleagueB != null) {
            colleagueB.operation();
        }

    }
}

/***
 *
 *@Author ChenjunWang
 *@Description:
 *@Date: Created in 10:59 2018/4/12
 *@Modified By:
 *
 */
public class Test {
    public static void main(String[] args) {
        ConcreteColleagueA concreteColleagueA = new ConcreteColleagueA();
        ConcreteColleagueB concreteColleagueB = new ConcreteColleagueB();
        ConcreteMediator concreteMediator = new ConcreteMediator(concreteColleagueA, concreteColleagueB);
        concreteMediator.notifyColleagueA();
        concreteMediator.notifyColleagueB();
    }
}
運行結果如下
------------------------------------------
同事A的操作
同事B的操作

雖然運行結果非常簡單，但是他們在調用的時候，不是直接調用的，而是通過ConcreteMediator來調用了。

其實我覺得通用的這個列子不能很好的表達出我對中介者模式的理解，我覺得還是用類似某企鵝的聊天工具來解釋會比較好理解。若沒有某企鵝，我們之間的聊天

每增加一個人，都要加好幾條線來確保正常溝通，關係非常複雜。
而當有某企鵝後，我們之間的關係變得簡單了，耦合度大大降低了

/***
 *
 *@Author ChenjunWang
 *@Description:中介者抽象類
 *@Date: Created in 13:34 2018/4/12
 *@Modified By:
 *
 */
public abstract class Mediator {

    List<User> list = new ArrayList<>();//所有在聊天室裏的人存這

    abstract void sendToAll(String msg);//羣發

    abstract void senToPerson(String msg, String name);//給某個人發送消息

    abstract void join(User user);//用戶加入聊天室

    abstract void leave(User user);//用戶離開聊天室
}

/***
 *
 *@Author ChenjunWang
 *@Description:聊天平臺
 *@Date: Created in 13:39 2018/4/12
 *@Modified By:
 *
 */
public class ChatPlatform extends Mediator {
    @Override
    void sendToAll(String msg) {

        for (User u : list){
            u.accept(msg);
        }
    }

    @Override
    void senToPerson(String msg, String name) {
        for (User u : list){

            if (u.name.equals(name))
                u.accept(msg);
        }

    }

    @Override
    void join(User user) {
        list.add(user);
    }

    @Override
    void leave(User user) {

        list.remove(user);
    }
}


/***
 *
 *@Author ChenjunWang
 *@Description:用戶抽象類
 *@Date: Created in 13:35 2018/4/12
 *@Modified By:
 *
 */
public abstract class User {
    protected Mediator mediator;
    String name;
    //在創建對象的時候就把他的中間者傳入，他要發送都是通過這個中介者來做的。
    public User(String name, Mediator mediator){
        this.name = name;
        this.mediator = mediator;
    }
    abstract void sendToAll(String msg);//給所有人發消息

    abstract void senToPerson(String msg, String name);//給某個人發送消息

    abstract void accept(String msg);//接受消息

    abstract void join();//加入聊天室

    abstract void leave();//離開聊天室
}

/***
 *
 *@Author ChenjunWang
 *@Description:普通用戶
 *@Date: Created in 13:42 2018/4/12
 *@Modified By:
 *
 */
public class NormalUser extends User {


    public NormalUser(String name, Mediator mediator) {
        super(name, mediator);
    }

    @Override
    void sendToAll(String msg) {
        mediator.sendToAll(msg);

    }

    @Override
    void senToPerson(String msg, String name) {

        mediator.senToPerson(msg, name);
    }

    @Override
    void accept(String msg) {
        System.out.println(this.name + "收到消息：" + msg );
    }

    @Override
    void join() {
        mediator.join(this);
    }

    @Override
    void leave() {

        mediator.leave(this);
    }
}
/***
 *
 *@Author ChenjunWang
 *@Description:
 *@Date: Created in 13:42 2018/4/12
 *@Modified By:
 *
 */
public class Test {
    public static void main(String[] args) {

        Mediator chatPlatform = new ChatPlatform();
        NormalUser a = new NormalUser("A", chatPlatform);
        NormalUser b = new NormalUser("B", chatPlatform);
        NormalUser c = new NormalUser("C", chatPlatform);
        a.join();
        b.join();
        c.join();
        System.out.println("-----------------A羣發送消息------------------");
        a.sendToAll("A：大家聽得到嗎?");
        System.out.println("-----------------A給B私發消息------------------");
        a.senToPerson("A：B,我只想和你說", "B");
        System.out.println("-----------------B給A私發消息------------------");
        b.senToPerson("B:可以，請說", "A");
        System.out.println("-----------------A離開聊天室------------------");
        a.leave();


        System.out.println("-----------------B羣發送消息------------------");
        b.sendToAll("B:A能聽到嗎");

    }
}
運行結果如下
-------------------------------------------------------------------------------

-----------------A羣發送消息------------------
A收到消息：A：大家聽得到嗎?
B收到消息：A：大家聽得到嗎?
C收到消息：A：大家聽得到嗎?
-----------------A給B私發消息------------------
B收到消息：A：B,我只想和你說
-----------------B給A私發消息------------------
A收到消息：B:可以，請說
-----------------A離開聊天室------------------
-----------------B羣發送消息------------------
B收到消息：B:A能聽到嗎
C收到消息：B:A能聽到嗎

以上便是LZ使用中介者模式實現了簡單的羣聊和單聊的模型。相信各位看官能理解中介者模式到底是幹嘛的了。所有用戶不再私下對話，全部交流都通過中介來完成，各個用戶關係解耦，依賴關係從之前的網狀變成星型。

像LZ日常用來開發的MVC 框架就是使用了中介者模式，其中Controller就是 Model和 View的中介者。

總結

優點

（1）解耦了類與類之間的關係
（2）將對象間多對多的關聯轉變爲一對多的關聯，使對象間的關係易於理解和維護。

缺點

（1）中介者的邏輯會變得很龐大，變得複雜難以維護.
（2）這是一箇中心化的模式，若中介者出現了問題，毫無疑問，整個系統將直接崩潰。

Git地址

本篇實例Github地址：https://github.com/stackisok/Design-Pattern/tree/master/src/mediator

回到最上方

有什麼不懂或者不對的地方，歡迎留言。
喜歡LZ文章的小夥伴們，可以關注一波，也可以留言，LZ會回你們的。
覺得寫得不錯的小夥伴，歡迎轉載，但請附上原文地址，謝謝^_^!