設計模式之中介者模式（Mediator ）

中介者模式是關於數據交互的設計模式，該模式的核心是一個中介者對象，負責協調一系列對象之間的不同的數據請求，這一系列對象成為同事類。如房產中介（簡直不想提它），買房的賣房的，租房的放租的都到房產中介那裡去登記。如果有賣房的就會通知買房的去買房，如果有放租的就會通知租房的去租房。所有的事物都是通過中介進 ...

中介者模式是關於數據交互的設計模式，該模式的核心是一個中介者對象，負責協調一系列對象之間的不同的數據請求，這一系列對象成為同事類。如房產中介（簡直不想提它），買房的賣房的，租房的放租的都到房產中介那裡去登記。如果有賣房的就會通知買房的去買房，如果有放租的就會通知租房的去租房。所有的事物都是通過中介進行通知轉換，這樣就形成了一個典型的星型結構，說道星型結構，網路中的交換機路由器不就是個大大的中介者麽。

作用

中介者模式包裝了一系列對象相互作用的方式，使得這些對象不必相互明顯作用。從而使它們可以鬆散耦合。當某些對象之間的作用發生改變時，不會立即影響其他的一些對象之間的作用。保證這些作用可以彼此獨立的變化。

類視圖

實現

中介者模式為拍賣行角色，負責買家、賣家和貨幣轉換的協調工作，其中印度買家和法國買家想拍賣美國賣家的東西，印度使用的是盧比，法國使用的是美元，而美國使用的是美元，所有的出價都要以美元進行結算；這樣就需要拍賣行來協調進行價格換算，拍賣競價等工作。

//頭文件mediator.h
#include <string>

class  Mediator;
 
class Colleage //同事類
{
public:
    Colleage(Mediator* md);
protected:
    Mediator *m_mediator;
};

class IndianBuyer: public Colleage
{
public:
    IndianBuyer(Mediator* md);
    void setTotalMoney(float fall);
    int Purchase(float bid);
private:
    float m_total_money; //買家的心理價位
};

class FrenchBuyer: public Colleage
{
public:
    FrenchBuyer(Mediator* md);
    void setTotalMoney(float fall);
    int Purchase(float bid);
private:
    float m_total_money;
};

class AmericanSeller: public Colleage
{
public:
    AmericanSeller(Mediator* md);
    void SetWantPrice(float price);
    bool IsBidAccept(float bidInDollars);
private:
    float m_priceInDollars; //賣家的心理價位
};

class DollorConver: public Colleage
{
public:
    DollorConver(Mediator* md);
    float ConverToDollars(float bid, std::string strName);
private:
    float ConverRupeetoDollar(float bid);
    float ConverEurotoDollar(float bid);
private:
    float dollor_unit; //美元換算比例
    float euro_unit;  //歐元換算比例
    float rupee_unit;//盧比換算比例
};

class Mediator
{
public:
    Mediator();
    void RegisterIndianBuyer(IndianBuyer* buyer);
    void RegisterFrenchBuyer(FrenchBuyer* buyer);
    void RegisterAmericanSeller(AmericanSeller* seller);
    void RegisterDollorConver(DollorConver* conver);
    bool placeBid(float bid,std::string strName);
private:
    IndianBuyer* m_pIndian;
    FrenchBuyer* m_pFrench;
    AmericanSeller* m_pAmerican;
    DollorConver* m_pConver;

};

mediator.cpp

#include <iostream>
#include "mediator.h"
using namespace std;

Colleage::Colleage(Mediator* md):m_mediator(md)
{
}
IndianBuyer::IndianBuyer(Mediator* md):Colleage(md),m_total_money(-1){
    m_mediator->RegisterIndianBuyer(this);
}
void IndianBuyer::setTotalMoney(float fall)
{
    m_total_money = fall;
}
int IndianBuyer::Purchase(float bid)
{
    //價格合適就出價一次
    if (m_total_money<0 || bid<= m_total_money)
    {
       return (int)m_mediator->placeBid(bid,"RUPEE"); 
    }
    else
    {
        return 2;//價格太高了  不要啦
    }
    
}

FrenchBuyer::FrenchBuyer(Mediator* md):Colleage(md),m_total_money(-1){
    m_mediator->RegisterFrenchBuyer(this);
}
void FrenchBuyer::setTotalMoney(float fall)
{
    m_total_money = fall;
}
int FrenchBuyer::Purchase(float bid)
{
    if (m_total_money<0 || bid<= m_total_money)
    {
       return (int)m_mediator->placeBid(bid,"EURO"); 
    }
    else
    {
        return 2;
    }
    
}

AmericanSeller::AmericanSeller(Mediator* md):Colleage(md),m_priceInDollars(0){
    m_mediator->RegisterAmericanSeller(this);
}
void AmericanSeller::SetWantPrice(float price)
{
    m_priceInDollars = price;
}
bool AmericanSeller::IsBidAccept(float bidInDollars)
{
    if (bidInDollars>=m_priceInDollars)
    {
       //當遇到價格增長時記錄最高的價格，沒有人超過這個價格就按照這個價格出售
        m_priceInDollars = bidInDollars;
        return true;
    }
    return false;
}

DollorConver::DollorConver(Mediator* md):Colleage(md)
,dollor_unit(1.0),euro_unit(0.7),rupee_unit(45.0){
    m_mediator->RegisterDollorConver(this);
}
float DollorConver::ConverToDollars(float bid, std::string strName)
{
    if (strName.compare("RUPEE")==0)
    {
        return ConverRupeetoDollar(bid);
    }
    else
    {
        return ConverEurotoDollar(bid);
    }
}
float DollorConver::ConverRupeetoDollar(float bid)
{
    return bid*(dollor_unit/rupee_unit);
}
float DollorConver::ConverEurotoDollar(float bid)
{
    return bid*(dollor_unit/euro_unit);
}


Mediator::Mediator():m_pIndian(NULL),m_pFrench(NULL)
,m_pAmerican(NULL),m_pConver(NULL){

}
void Mediator::RegisterIndianBuyer(IndianBuyer* buyer)
{
    m_pIndian = buyer;
}
void Mediator::RegisterFrenchBuyer(FrenchBuyer* buyer)
{
    m_pFrench = buyer;
}
void Mediator::RegisterAmericanSeller(AmericanSeller* seller)
{
    m_pAmerican = seller;
}
void Mediator::RegisterDollorConver(DollorConver* conver)
{
    m_pConver = conver;
}
bool Mediator::placeBid(float bid,std::string strName)
{
    float dollars =  m_pConver->ConverToDollars(bid,strName);
    return m_pAmerican->IsBidAccept(dollars);
}


int main(int argc,char *argv[])
{
    Mediator mediatior;

    IndianBuyer indian(&mediatior);
    FrenchBuyer french(&mediatior);
    AmericanSeller american(&mediatior);
    DollorConver conver(&mediatior);
    
    indian.setTotalMoney(6000);
    french.setTotalMoney(100);

    american.SetWantPrice(50);
    
    int  nIndian = 0;
    int  nFrench = 0;
    float IndianBid = 2000;
    float FrenchBid = 30;
    //一輪一輪進行出價，當有一個出不起的時候，就結束競價。
    while(nIndian+nFrench<=2)
    {
        do{
            nIndian = indian.Purchase(IndianBid);
            IndianBid+=100;
            if (nIndian == 1)
            {
                cout<<"indian purchase : "<< IndianBid <<endl;
            }
            
        }
        while(nIndian==0);

        do{
            nFrench = french.Purchase(FrenchBid);
            FrenchBid+=1.5;
            if (nFrench == 1)
            {
                cout<<"french purchase : "<< FrenchBid <<endl;
            }
        }
        while(nFrench==0);

    }

    return 0;

}

當我們開始任何產品研發的時候總會有一些類，這些類會使用到之前產品的研發成果，隨著功能的增加，邏輯會變得更加複雜，我們會添加更多的類和之前的類互相作用，知道難以維護所有的代碼。中介者模式關心的就是這個問題，它會使代碼更容易維護。它能夠實現類之間的鬆散耦合。只有中介者這一個類知道所有的類，其他類只需要與中介者進行交互即可，當然更加集中的控制也會帶來中樞的龐大，還是需要避免過度的集成。

應用場景

一組對象使用了標準的通信方式，但整體通信的連接都非常複雜，由此產生的相互依賴的結構導致系統難以結構化，也很難理解；
由於對象之間的通信和相互引用，導致對象難以重用。
分佈於對個類中間的行為能夠統一定製化，而無需創建過多的子類。