23种设计模式(18)--Mediator模式

使用了Mediator模式，原来在各个对象内部所做的事情，现在全部移交到Mediator里了。也就是将分布在各个对象里面的协议处理过程，全部统一放在Mediator里去做了。骤看来，好像我们是把职责转移了，但是对于代码逻辑的清晰却有很大的好处，这个模式让我们能专注于各个对象之间的交互（他们的交互都放在Mediator类里去做了）。Mediator的核心思想就是把错综复杂的类间的关系独立出来，使得他们的关系清晰化。这样做的好处是如果类间的交互协议有变化，则只修改Mediator类就行了，但是它的缺点也在于Mediator类，因为所有的交互都转移到Mediator中，他的复杂性可想而知，搞不好会变成一个庞然大物，难以维护。

Mediator模式结构图：



代码实现：

#include "iostream"
#include <string>
using namespace std;

class Mediator {
public:
virtual ~Mediator(){};
virtual void DoActionFromAtoB() = 0;
virtual void DoActionFromBtoA() = 0;
protected:
Mediator(){};
private:
};
class Colleage
{
public:
virtual ~Colleage(){};
virtual void Aciton() = 0;
virtual void SetState(const string& sdt) = 0;
virtual string GetState() = 0; protected: Colleage();
Colleage(Mediator* mdt);
Mediator* _mdt;
private:
};
class ConcreteColleageA :public Colleage
{
public:
ConcreteColleageA(){};
ConcreteColleageA(Mediator* mdt);
~ConcreteColleageA(){};
void Aciton();
void SetState(const string& sdt);
string GetState();
protected:
private:
string _sdt;
};
class ConcreteColleageB :public Colleage
{
public:
ConcreteColleageB(){};
ConcreteColleageB(Mediator* mdt);
~ConcreteColleageB(){};
void Aciton();
void SetState(const string& sdt);
string GetState();
protected:
private:
string _sdt;
};

Colleage::Colleage(Mediator* mdt)
{
this->_mdt = mdt;
}
ConcreteColleageA::ConcreteColleageA(Mediator* mdt) :Colleage(mdt)
{
}

string ConcreteColleageA::GetState()
{
return _sdt;
}
void ConcreteColleageA::SetState(const string& sdt)
{
_sdt = sdt;
}
void ConcreteColleageA::Aciton()
{
this->_mdt->DoActionFromAtoB();
cout << "State of ConcreteColleageB:" << " " << this->GetState() << endl;
}

ConcreteColleageB::ConcreteColleageB(Mediator* mdt) :Colleage(mdt)
{
}
void ConcreteColleageB::Aciton()
{
this->_mdt->DoActionFromBtoA();
cout << "State of ConcreteColleageB:" << " " << this->GetState() << endl;
}
string ConcreteColleageB::GetState()
{
return _sdt;
}
void ConcreteColleageB::SetState(const string& sdt)
{
_sdt = sdt;
}

class ConcreteMediator :public Mediator
{
public:
ConcreteMediator(){};
ConcreteMediator(Colleage* clgA, Colleage* clgB);
~ConcreteMediator(){};
void SetConcreteColleageA(Colleage* clgA);
void SetConcreteColleageB(Colleage* clgB);
Colleage* GetConcreteColleageA();
Colleage* GetConcreteColleageB();
void IntroColleage(Colleage* clgA, Colleage* clgB);
void DoActionFromAtoB();
void DoActionFromBtoA();
protected:
private:
Colleage* _clgA;
Colleage* _clgB;
};
ConcreteMediator::ConcreteMediator(Colleage* clgA, Colleage* clgB)
{
this->_clgA = clgA;
this->_clgB = clgB;
}
void ConcreteMediator::DoActionFromAtoB()
{
_clgB->SetState(_clgA->GetState());
}
void ConcreteMediator::SetConcreteColleageA(Colleage* clgA)
{
this->_clgA = clgA;
}
void ConcreteMediator::SetConcreteColleageB(Colleage* clgB)
{
this->_clgB = clgB;
}
Colleage* ConcreteMediator::GetConcreteColleageA()
{
return _clgA;
}
Colleage* ConcreteMediator::GetConcreteColleageB()
{
return _clgB;
}
void ConcreteMediator::IntroColleage(Colleage* clgA, Colleage* clgB)
{
this->_clgA = clgA;
this->_clgB = clgB;
}
void ConcreteMediator::DoActionFromBtoA()
{
_clgA->SetState(_clgB->GetState());
}

int main(int argc, char* argv[])
{
ConcreteMediator* m = new ConcreteMediator();
ConcreteColleageA* c1 = new ConcreteColleageA(m);
ConcreteColleageB* c2 = new ConcreteColleageB(m);
m->IntroColleage(c1, c2);
c1->SetState("old");
c2->SetState("old");
c1->Aciton();
c2->Aciton();
cout << endl;

c1->SetState("new");
c1->Aciton();
c2->Aciton();
cout << endl;

return 0;
}