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;
}