Mediator Patterns

GoF定義：定義一個物件來處理一組物件的互動。中介者模式通過避免物件之間互相引用提高了解耦程度，允許使用者獨立改變它們各自的互動操作

概念

中介者是負責一組物件互動的。它會追蹤各個物件之間的交流記錄。系統中的其它物件也知道有這個中介者的存在，當它們想和其它的物件互動時，也需要通過中介者。使用這個模式的優點就是可以避免物件之間的直接互動並且降低耦合度

例子

現實世界：在機場中，所有的飛機在起飛之前都要進行元件（互相依賴）的檢查，確保安全狀態起飛。此外，每個飛行員都需要和不同機場的航站樓交流，然而他一般不需要和另一個機場的另一個飛行員交流，此時航站樓就是中介者的角色
程式碼世界：在表單提交的場景中，使用者需要提交使用者id、密碼、email等資訊，如果在實現中，當用戶提供的id正確才能繼續輸密碼，如果id、密碼正確才能提供一些其它的認證資訊，一旦任何一個資訊不滿足驗證，那麼提交按鈕就不可用。這個邏輯的實現可以通過中介者模式實現

展示

這個場景中有三個類實現了Friend介面，其中有一個老闆和兩個員工。老闆希望有人給他發訊息時他可以收到，且他要給員工發訊息，員工也可以馬上收到。這裡訊息的傳遞就是通過中介者完成的

程式碼

public class MediatorPatternEx
{
    public static void main(String[] args)
    {
        System.out.println("***Mediator Pattern Demo***\n");
        ConcreteMediator m = new ConcreteMediator();
        Friend1 Amit= new Friend1("Amit", m);
        Friend2 Sohel = new Friend2("Sohel", m);
        Boss Raghu = new Boss("Raghu", m);
        m.setFriend1(Amit);
        m.setFriend2(Sohel);
        m.setBoss(Raghu);
        Amit.send("[Amit here]Good Morrning. Can we discuss the mediator pattern?");
        Sohel.send("[Sohel here]Good Morning.Yes, we can discuss now.");
        Raghu.send("\n[Raghu here]:Please get back to work quickly");
    }
}

/**
 * 所有的中介者都需要有傳送資訊的能力
 */
abstract class Mediator
{
    abstract public void send(Friend friend, String message);
}

class ConcreteMediator extends Mediator
{
    private Friend1 friend1;
    private Friend2 friend2;
    private Boss boss;

    public void setFriend1(Friend1 friend1)
    {
        this.friend1 = friend1;
    }

    public void setFriend2(Friend2 friend2)
    {
        this.friend2 = friend2;
    }

    public void setBoss(Boss boss)
    {
        this.boss = boss;
    }

    @Override
    public void send(Friend friend, String message)
    {
        if (friend == friend1)
        {
            friend2.notify(message);
            boss.notify(message);
        }
        else if (friend == friend2)
        {
            friend1.notify(message);
            boss.notify(message);
        }
        else
        {
            friend1.notify(message);
            friend2.notify(message);
        }
    }
}

abstract class Friend
{
    public String name;
    protected Mediator mediator;

    public Friend(Mediator mediator)
    {
        this.mediator = mediator;
    }
}

class Friend1 extends Friend
{
    public Friend1(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("Amit gets message: "+ message);
    }
}

class Friend2 extends Friend
{
    public Friend2(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("Sohel gets message: "+ message);
    }
}

class Boss extends Friend
{
    public Boss(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("\nBoss sees message: " + message);
        System.out.println("");
    }
}
 

Note

1. 當我們要觀察物件之間複雜的互動過程可以使用這個模式，且物件之間的互動通過這個模式變得更簡單
2. 這個模式減少了系統中子類的數量（我理解這裡的意思是，如果沒有中介者物件，那麼各個物件的通訊可能會製造很多通訊介面類），降低了耦合度
3. 多對多關係被一對多關係替代，提高可讀性
4. 這個模式可以在中心（中介者）做控制
5. 難以維護

思考

這個模式書中的例子確實很好理解。即中介者就是做物件之間的訊息轉發的，當然同時可以記錄所有的通訊資訊，相當於是中央控制的設計思想