Observer(观察者)设计模式

声明：本博文篇幅短，适合review。

一、概念

       定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

二、模式结构图

class Observer;

class Subject
{
public:
	virtual ~Subject();
	virtual void attach(Observer * obsv){
		mObsvs->push_front(obsv);
	}
	virtual void detach(Observer * obsv){
		if (obsv != NULL){
			mObsvs->remove(obsv);
		}
	}
	virtual void notify(){
		std::list<Observer *>::iterator it = mObsvs->begin();
		for (; it != mObsvs->end(); it++){
			(*it)->update(this);
		}
	}

	virtual void setState(const std::string & str) = 0;
	virtual std::string getState() = 0;
protected:
	Subject(){
		mObsvs = new std::list<Observer *>;
	}
private:
	std::list<Observer *> * mObsvs;
};

class ConcreteSubject : public Subject
{
public:
	ConcreteSubject(){
		mState = "";
	}
	~ConcreteSubject();

	std::string getState(){
		return mState;
	}
	void setState(const std::string & str){
		mState = str;
	}
private:
	std::string mState;
};

class Observer
{
public:
	virtual void update(Subject * sub) = 0;
};

class ConcreteObserverA : public Observer
{
public:
	ConcreteObserverA(Subject * sub){
		mSub = sub;
		mSub->attach(this);
	}
	~ConcreteObserverA(){
		mSub->detach();
	}
	void update(Subject * sub){
		cout<<"ConcreteObserverA update : state---"<<sub->getState()<<endl;
	}
private:
	Subject * mSub;
};

class ConcreteObserverB : public Observer
{
public:
	ConcreteObserverB(Subject * sub){
		mSub = sub;
		mSub->attach(this);
	}
	~ConcreteObserverB(){
		mSub->detach();
	}
	void update(Subject * sub){
		cout<<"ConcreteObserverB update : state---"<<sub->getState()<<endl;
	}
private:
	Subject * mSub;
};

void main(){
	Subject * sub = new ConcreteSubject();
	Observer * ob1 = new ConcreteObserverA(sub);
	Observer * ob2 = new ConcreteObserverB(sub);
	sub->setState("xxx");
	sub->notify();
	sub->setState("yyy");
	sub->notify();
}

三、例子

class Boss;

class Staff
{
public:
	virtual ~Staff();
	virtual void attach(Boss * bs){
		mBs->push_front(bs);
	}
	virtual void detach(Boss * bs){
		if (bs != NULL){
			mBs->remove(bs);
		}
	}
	virtual void notify(){
		std::list<Boss *>::iterator it = mBs->begin();
		for (; it != mBs->end(); it++){
			(*it)->update(this);
		}
	}

	virtual void setState(const std::string & str) = 0;
	virtual std::string getState() = 0;
protected:
	Staff(){
		mBs = new std::list<Boss *>;
	}
private:
	std::list<Boss *> * mBs;
};

class Receptionist : public Staff
{
public:
	Receptionist(){
		mState = "";
	}
	~Receptionist();

	std::string getState(){
		return mState;
	}
	void setState(const std::string & str){
		mState = str;
	}
private:
	std::string mState;
};

class Boss
{
public:
	virtual void update(Staff * stf) = 0;
};

class CTO : public Boss
{
public:
	CTO(Staff * stf){
		mStf = stf;
		mStf->attach(this);
	}
	~CTO(){
		mStf->detach();
	}
	void update(Staff * stf){
		cout<<"CTO update : state---"<<stf->getState()<<endl;
	}
private:
	Staff * mStf;
};

class Manager : public Boss
{
public:
	Manager(Staff * stf){
		mStf = stf;
		mStf->attach(this);
	}
	~Manager(){
		mStf->detach();
	}
	void update(Staff * stf){
		cout<<"Manager update : state---"<<stf->getState()<<endl;
	}
private:
	Staff * mStf;
};

void main(){
	Staff * xiaoli = new Receptionist();
	Boss * cto = new CTO(xiaoli);
	Boss * manger = new Manager(xiaoli);
	xiaoli->setState("有快递来啦~");
	xiaoli->notify();
	xiaoli->setState("有人来面试啦～");
	xiaoli->notify();
}

四、优缺点

       1、优点

             a、降低了观察者与被观察者之间的耦合。

             b、Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。

             c、观察者模式支持广播通信。

       2、缺点

             a、观察者过多，存在效率问题。

             b、松耦合可能导致关系不明确而不易理解。