[设计模式]Observer观察者模式

问题

Observer模式应该可以说是应用最多，影响最广的模式之一，因为Observer的一个实例Model/View/Control(MVC)结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表示层的解耦。在MFC中，Doc/View(文档视图结构)提供了实现MVC的框架结构。还有在事件处理系统中也经常用到。

将一个系统分割成一系列相互协作的类有一个很不好的副作用，就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合，这样会给维护，扩展和重用带来不便。

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

观察者模式

观察者模式又叫做发布-订阅(Publish/Subscribe)模式，目标就是通知的发布者，观察者则是通知的订阅者(接受通知)。

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。

抽象主题(Subject):它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加，删除观察者对象，并且提供了观察者同步的操作(Notify).

具体主题(ConcreteSubject):将有关状态引入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。

抽象观察者(Observer)：为所有具体观察者定义一个接口，在得到主题通知时更新自己。

具体观察者(ConcreteObserver):实现抽象观察者角色所要求的更新接口，以便使本身的主题状态协调。

Observer模式实现的要点是：

1.一般Subject类都是采用链表等容器来存放Observer对象

2.抽取出Observer对象的一些公共属性形成Observer基类，而Subject中保存的则是Observer类对象的指针，这样就使Subject和具体的Observer实现了解耦，也就是Subject不需要去关心到底是哪个Observer对放进了自己的容器中。

小demo

Observer.h

/********************************************************************
	created:	2006/07/20
	filename: 	Observer.h
	author:		李创
                http://www.cppblog.com/converse/
	purpose:	Observer模式的演示代码
*********************************************************************/

#ifndef OBSERVER_H
#define OBSERVER_H

#include <list>
typedef int STATE;
class Observer;
// Subject抽象基类,只需要知道Observer基类的声明就可以了，可以译为主题或抽象通知者。
//实现观察者模式的形式其实就是"注册——通知——注销"
class Subject
{
public:
	Subject() : m_nSubjectState(-1){}
	virtual ~Subject();

	void Notify();							// 通知所有观察者对象
	void Attach(Observer *pObserver);		// 新增一个观察者对象
	void Detach(Observer *pObserver);		// 删除一个观察者对象

	// 虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现
	virtual void	SetState(STATE nState)=0;	// 设置状态
	virtual STATE	GetState()=0;		// 得到状态

protected:
	STATE m_nSubjectState;					// 模拟保存Subject状态的变量
	std::list<Observer*>	m_ListObserver;	// 保存Observer指针的链表
};
 
//Observe类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题通知时更新自己。这个接口叫做更新接口。更新接口通常包含一个Update()方法，这个方法叫做更新方法
class Observer
{
public:
	Observer() : m_nObserverState(-1){}
	virtual ~Observer(){}

	// 纯虚函数,各个派生类可能有不同的实现
	// 通知Observer状态发生了变化
	virtual void Update(Subject* pSubject) = 0;
protected:
	STATE m_nObserverState;					// 模拟保存Observer状态的变量
};

// ConcreateSubject类,派生在Subject类，叫做具体主题或具体通知者
class ConcreateSubject	: public Subject
{
public:
	ConcreateSubject() : Subject(){}
	virtual ~ConcreateSubject(){}

	// 派生类自己实现来覆盖基类的实现,是成对出现的，由Subject来设置状态，由Observer来得到改变的状态
	virtual void	SetState(STATE nState);	// 设置状态
	virtual STATE	GetState();		// 得到状态
};

// ConcreateObserver类派生自Observer
class ConcreateObserver : public Observer 
{
public: 
	ConcreateObserver():Observer(){}
	ConcreateObserver(Subject* sub);//使用其构造函数，省去了在其外部调用sub->Attach
	virtual ~ConcreateObserver(){}

	// 虚函数,实现基类提供的接口
	virtual void Update(Subject* pSubject);
};

#endif

Observer.cpp

/********************************************************************
	created:	2006/07/20
	filename: 	Observer.cpp
	author:		李创
                http://www.cppblog.com/converse/
	purpose:	Observer模式的演示代码
*********************************************************************/

#include "Observer.h"
#include <iostream>
#include <algorithm>

/* --------------------------------------------------------------------
|	Subject类成员函数的实现 
 ----------------------------------------------------------------------*/
void Subject::Attach(Observer *pObserver)
{
	std::cout << "Attach an Observer\n";
	m_ListObserver.push_back(pObserver);
}

void Subject::Detach(Observer *pObserver)
{
	std::list<Observer*>::iterator iter;
	iter = std::find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);

	if (m_ListObserver.end() != iter)
	{
		m_ListObserver.erase(iter);
	}
	std::cout << "Detach an Observer\n";
}

void Subject::Notify()
{
	std::cout << "Notify Observers's State\n";
	std::list<Observer*>::iterator iter1, iter2;
	for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end(); iter1 != iter2;++iter1)
	{
		(*iter1)->Update(this);
	}
} 

Subject::~Subject()
{
	std::list<Observer*>::iterator iter1, iter2, temp;
	for (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();iter1 != iter2;)
	{
		temp = iter1;
		++iter1;
		delete (*temp);
	}
	m_ListObserver.clear();
}

/* --------------------------------------------------------------------
|	ConcreateSubject类成员函数的实现 
----------------------------------------------------------------------*/
void ConcreateSubject::SetState(STATE nState)
{
	std::cout << "SetState By ConcreateSubject\n";
	m_nSubjectState = nState;
	//Notify();也可以写在内部，这样就不用每次调用SetState()后在调用Notify()
}

STATE ConcreateSubject::GetState()
{
	std::cout << "GetState By ConcreateSubject\n";
	return m_nSubjectState;
}

/* --------------------------------------------------------------------
|	ConcreateObserver类成员函数的实现 
----------------------------------------------------------------------*/ 
ConcreateObserver::ConcreateObserver(Subject* sub) : Observer()
{
	sub->Attach(this);
}
void ConcreateObserver::Update(Subject* pSubject)
{
	if (NULL == pSubject)
		return;
	m_nObserverState = pSubject->GetState(); 
	std::cout << "The ObeserverState is " << m_nObserverState << std::endl;
}

Main.cpp

/********************************************************************
	created:	2006/07/21
	filename: 	Main.cpp
	author:		李创
                http://www.cppblog.com/converse/

	purpose:	Observer模式的测试代码
*********************************************************************/

#include "Observer.h"
#include <iostream>

int main()
{
	Subject* p = new ConcreateSubject();
	Observer *p1 = new ConcreateObserver(p);
	Observer *p2 = new ConcreateObserver(p);//等价于Observer *p2 = new ConcreateObserver();	p->Attach(p2); 
	p->SetState(4);
	p->Notify();

    std::cout<<"-----------------------"<<std::endl;
	p->Detach(p1);
	p->SetState(10);
	p->Notify();

	delete p;
	system("pause");
	return 0;
}
/************************************************************************
 代码说明：在Observer模式的实现中，Subject维护一个List作为存储其所有观察者的容器。每当调用Notify操作就遍历List中Observer对象，并广播通知改变状态了(调用Observer的Update操作)。
目标的状态state可以有Subject自己改变，也可以有Observer的某个操作引起state的改变(可调用Subject的SetState操作)
当然，可以有多个Subject子类，和多个Observer的子类，也可以有多个要通知的消息。
************************************************************************/

输出结果

观察者模式的实质

观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。