23种设计模式之——Observer模式

    

Observer 模式应该可以说是应用最多、影响最广的模式之一，因为 Observer 的一个实例 Model/View/Control（MVC）结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表示层的解耦。为个人也认为 Observer  模式是软件开发过程中必须要掌握和使用的模式之一。在 Java 阵容中，Struts 则提供和 MFC 中Doc/View 结构类似的实现MVC 的框架。另外 Java语言本身就提供了 Observer 模式的实现接口，这将在讨论中给出。

 

Observer 模式要解决的问题为：建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，依赖这个“一”的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，我们希望能够提供多种形式的表示 （例如以表格进行统计显示、 柱状图统计显示、 百分比统计显示等） 。这些表示都依赖于同一组数据， 我们当然需要当数据改变的时候， 所有的统计的显示都能够同时改变。Observer 模式就是解决了这一个问题。

我们来举个简单的例子，现在房价不是超级高吗，出现新的楼盘，各种人包括买房的，房屋中介的都蜂拥而至。结果就会出现问题，一是

买房的不可能天天盯着房子信息啥也不干呀，二是每个人都问有房吗，楼盘服务人员也很忙。因此，大家就商量了一个对策：买房的人作为

Observer，当然具体不同的人就是不同的ConcreteObserver。这些人不用天天盯着房子信息看了，只需要把个人信息在该楼盘登记（Attach）

一下，当然如果不想买了可以把信息去了（Detach），并留下楼盘电话方便有房的时候联系。楼盘服务人员作为subject，掌管着楼盘状态

信息（State）以及注册的买房者信息。一旦有房子，他就会通知（Notify）所有的买房者，有房啦，然后每个买房者ConcreteObserver就会

打电话问问楼盘服务人员哪个位置有房啦，几层呀之类的，然后决定买不买（Update）。

	具体说来，这里的目标 Subject 提供依赖于它的观察者 Observer 的注册（Attach）和注销（Detach）操作，在Subject里面维护了一个

注册的Observer集合信息（如Observer链表）以及他们感兴趣的目标状态（State）。一旦目标状态发生变化，Subject就会通知（Notify）

所有的Observer ，一般在Notify中会调用Observer 的Update 操作，因此这里的 Observer 的 Update 操作并不在 Observer 改变了 

Subject 目标状态的时候就对自己进行更新，这个更新操作要延迟到 Subject 对象发出 Notify 通知所有Observer 进行修改（调用 Update） 。

每一个Observer一般都会维护一个Subject的指针，用于注册信息，和获取目标状态变化，就像留个楼盘手机号一样。

下面给代码，首先是Subject:

#ifndef _SUBJECT_H_
#define _SUBJECT_H_
#include <list>
#include <string>
using namespace std;
typedef string State;
class Observer;


class Subject
{
public:
	virtual ~Subject();
	virtual void Attach(Observer* obv);
	virtual void Detach(Observer* obv);
	virtual void Notify();
	virtual void SetState(const State& st) = 0;
	virtual State GetState() const = 0;


protected:
	Subject();


private:
	list<Observer* >* _obvs;
};


class ConcreteSubject :public Subject
{
public:
	ConcreteSubject();
	~ConcreteSubject();
	State GetState() const;
	void SetState(const State& st);


protected:


private:
	State _st;
};
#endif //~_SUBJECT_H_

#include "stdafx.h"
#include "Subject.h"
#include "Observer.h"
#include <iostream>
#include <list>

using namespace std;

typedef string state;

Subject::Subject()
{  //在模板的使用之前一定要new创建
	_obvs = new list<Observer*>;
}

Subject::~Subject()
{ 
}

void Subject::Attach(Observer* obv)
{
	_obvs->push_front(obv);
}

void Subject::Detach(Observer* obv)
{
	if (obv != NULL)
		_obvs->remove(obv);
}

void Subject::Notify()
{
	list<Observer*>::iterator it;
	it = _obvs->begin();
	for (; it != _obvs->end(); it++)
	{ //关于模板和 iterator 的用法
		(*it)->Update(this);
	}
}

ConcreteSubject::ConcreteSubject()
{
	_st = '\0';
}

ConcreteSubject::~ConcreteSubject()
{ 
}

State ConcreteSubject::GetState() const
{
	return _st;
}
void ConcreteSubject::SetState(const State& st)
{
	_st = st;
}

然后是Observer:

#ifndef _OBSERVER_H_
#define _OBSERVER_H_

#include "stdafx.h"
#include "Subject.h"
#include <string>

using namespace std;

typedef string State;

class Observer
{
	public:
		virtual ~Observer();
		virtual void Update(Subject* sub) = 0;
		virtual void PrintInfo() = 0;
	protected:
		Observer();
		State _st;
	private:
};

class ConcreteObserverA :public Observer
{
	public:
		virtual Subject* GetSubject();
		ConcreteObserverA(Subject* sub);
		virtual ~ConcreteObserverA();
		//传入 Subject 作为参数，这样可以让一个View 属于多个的 Subject。
		void Update(Subject* sub);
		void PrintInfo();
	protected:
	private:
		Subject* _sub;
};

class ConcreteObserverB :public Observer
{
	public:
		virtual Subject* GetSubject();
		ConcreteObserverB(Subject* sub);
		virtual ~ConcreteObserverB();
		//传入Subject作为参数，这样可以让一个View属于多个的Subject。
		void Update(Subject* sub);
		void PrintInfo();
	protected:
	private:
		Subject* _sub;
};
#endif //~_OBSERVER_H_

#include "stdafx.h"
#include "Observer.h"
#include "Subject.h"
#include <iostream>
#include <string>
using namespace std;

Observer::Observer()
{
	_st = '\0';
}
Observer::~Observer()
{
}

ConcreteObserverA::ConcreteObserverA(Subject* sub)
{
	_sub = sub;
	_sub->Attach(this);
}

ConcreteObserverA::~ConcreteObserverA()
{
	_sub->Detach(this);
	if (_sub != 0)
		delete _sub;
}

Subject* ConcreteObserverA::GetSubject()
{
	return _sub;
}

void ConcreteObserverA::PrintInfo()
{
	cout << "ConcreteObserverA  observer...."<<_st<<endl;
}

void ConcreteObserverA::Update(Subject* sub)
{
	_st = sub->GetState();
	PrintInfo();
}

ConcreteObserverB::ConcreteObserverB(Subject* sub)
{
	_sub = sub;
	_sub->Attach(this);
}

ConcreteObserverB::~ConcreteObserverB()
{
	_sub->Detach(this);
	if (_sub != 0)
	{
		delete _sub;
	}
}

Subject* ConcreteObserverB::GetSubject()
{
	return _sub;
}

void ConcreteObserverB::PrintInfo()
{
	cout << "ConcreteObserverB  observer...." << _st << endl;
}

void ConcreteObserverB::Update(Subject* sub)
{
	_st = sub->GetState();
	PrintInfo();
}

最后给出main函数：

#include "stdafx.h"
#include "Subject.h"
#include "Observer.h"
#include <iostream>
using namespace std;

int main()
{
	ConcreteSubject*  sub = new ConcreteSubject();
	Observer*  o1 = new ConcreteObserverA(sub);
	Observer*  o2 = new ConcreteObserverB(sub);
	sub->SetState("old");
	sub->Notify();
	sub->SetState("new");  // 也可以由Observer调用
	sub->Notify();

	return 0;
}

运行结果如图：