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

问题

Observer模式应该可以说是应用最多，影响最广的模式之一，因为Observer的一个实例Model/View/Control(MVC)结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表示层的解耦。在MFC中，Doc/View(文档视图结构)提供了实现MVC的框架结构。还有在事件处理系统中也经常用到，事件分发机制就是采用的观察者模式。观察者模式是实现解耦的一种方法，它的有名应用是MVC和[b]事件分发机制。[/b]只要有界面处理的地方，就会有事件产生；有事件就会用到事件分发机制；而事件分发机制就是采用的观察者模式。
将一个系统分割成一系列相互协作的类有一个很不好的副作用，就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合，这样会给维护，扩展和重用带来不便。
Observer模式要解决的问题为：建立一个一(Subject)对多(Observer)的依赖关系，并且做到"一"变化的时候，依赖这个"一"的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，我们希望能够提供多种形式的表示(表格统计显示，柱状图统计显示，百分比统计显示)。这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计显示都能够同时改变。Observer模式就是解决这种一对多的依赖关系(耦合关系)的问题。
应用实例
应用多个对象依赖同一个对象的情况。其中这(多个对象是观察者)，这(一个对象是被观察者)。
1.老师的电话号码改变时自动通知学生。 2.对同一组数据用不同的图片表现出来(条形，柱状，百分图)。
3.观察者模式还可以用于网络中的客户端和服务器，比如手机中的各种App的消息推送，服务端是被观察者，各个手机App是观察者，一旦服务器上的数据(如App升级信息)有更新，就会被推送到手机客户端。

观察者模式

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。目标就是通知的发布者，观察者则是通知的订阅者(接受通知)。观察者模式，顾名思意就是观察与被观察的关系。
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。 


抽象主题(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);
};

#endifObserver.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的子类，也可以有多个要通知的消息。
************************************************************************/ 输出结果

观察者模式的实质

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

在设计观察者模式的程序时要注意以下几点： 
1. 要明确谁是观察者谁是被观察者，只要明白谁是关注对象，问题也就明白了。一般观察者与被观察者之间的是多对一的关系，一个被观察对象可以有多个监听对象(观察者)。如一个编辑框，有鼠标点击的监听者，也有键盘的监听者，还有内容改变的监听者。 
2. Observable在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。 
3. 被观察者至少需要有三个方法:添加监听者、移除监听者、通知Observer的方法；观察者至少要有一个方法：更新方法，更新当前的内容，作出相应的处理。 
注:添加监听者、移除监听者在不同的模型中可能会有不同命名，如观察者模型中一般，addObserver、removeObserver；在源-监听器(Source/Listener)模型中一般是attach/detach，应用在桌面编程的窗口中，还可能是attachWindow /detachWindow，或Register/UnRegister。不要被名称迷糊了，不管他们是什么名称，其实功能都是一样的，就是添加/删除观察者。 
4. 观察者模式的应用场景： 

对一个对象状态的更新需要其他对象同步更新;，或者一个对象的更新需要依赖另一个对象的更新；
对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节，如消息推送。

观察者模式是实现解耦的一种方法。

推模型和拉模型

观察者模式根据其侧重的功能还可以分为推模型和拉模式 
推模型：被观察者对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。一般这种模型的实现中，会把被观察者对象中的全部或部分信息通过update的参数传递给观察者[update(Object obj) ]。 
拉模型：被观察者在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到被观察者对象中获取，相当于是观察者从被观察者对象中拉数据。一般这种模型的实现中，会把被观察者对象自身通过update方法传递给观察者[update(Observable observable ) ]，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。