设计模式之中介者模式（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;

}

当我们开始任何产品研发的时候总会有一些类，这些类会使用到之前产品的研发成果，随着功能的增加，逻辑会变得更加复杂，我们会添加更多的类和之前的类互相作用，知道难以维护所有的代码。中介者模式关心的就是这个问题，它会使代码更容易维护。它能够实现类之间的松散耦合。只有中介者这一个类知道所有的类，其他类只需要与中介者进行交互即可，当然更加集中的控制也会带来中枢的庞大，还是需要避免过度的集成。

应用场景

1. 一组对象使用了标准的通信方式，但整体通信的连接都非常复杂，由此产生的相互依赖的结构导致系统难以结构化，也很难理解；
2. 由于对象之间的通信和相互引用，导致对象难以重用。
3. 分布于对个类中间的行为能够统一定制化，而无需创建过多的子类。