定义
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
Observer模式描述了如何建立这种关系。这一模式中的关键对象是目标（subject）和观察者（observer）。一个目标可以有任意数目的依赖它的观察者。一旦目标的状态发生改变，所有的观察者都得到通知。这种交互也称为发布-订阅（publish-subscribe）。目标是通知的发布者。故观察者模式又名 依赖（Dependents），发布-订阅（Publish-Subscribe）。
适用场景
以下任何一种情况可以使用观察者模式：
- 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这两者封装在独立的对象中以使它们可以各自独立地改变和复用。
- 当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
- 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象是紧密耦合的。
代码示例
观察者模式，首先需要定义观察者基类（接口）Observer和目标基类（接口）Subject，观察者基类需要对外提供一个接口函数Update，Update是一个纯虚函数，方便多态的实现，供目标通知观察者更新。
class Subject;
class Observer{
public:
virtual ~Observer();
virtual void Update(Subject* theChangedSubject) = ;
protected:
Observer();
};
目标基类需要提供支持观察者订阅函数Attach；观察者取消订阅函数Detach；对已订阅的所有观察者进行广播的函数Notify，在目标变化后，该函数遍历通知所有已订阅的观察者；以及用于存储已订阅该目标的所有观察者的列表结构List。
class Subject{
public:
virtual ~Subject();
virtual void Attach(Observer *);
virtual void Detach(Observer *);
virtual void Notify();
protected:
Subject();
private:
List<Observer *> *_observers;
};
void Subject::Attach(Observer* o){
_observers->Append(o);
}
void Subject::Detach(Observer *o){
_observers->Remove(o);
}
void Subject::Notify(){
ListIterator<Observer*> i(_observers);
for(i.First(); !i.IsDone(); i.Next()){
i.CurrentItem->Update(this);
}
}
基于目标接口类Subject和观察者接口类Observer，下面是GOF写的设计模式一书中的观察者模式应用——一个简单的时钟，每当定时器滴答一下，定时器（目标）就会通知时钟（观察者）绘制界面更新显示。
ClockTimer是基于目标接口类实现的目标实例，GetHour、GetMinute、GetSecond分别用于获取时、分、秒，Tick函数为计时器实现函数，每过一个滴答时刻，该函数就会调用目标基类的Notify函数通知所有已订阅观察者对象。
class ClockTimer::public Subject{
public:
ClockTimer();
virtual int GetHour();
virtual int GetMinute();
virtual int GetSecond();
void Tick();
};
void ClockTimer::Tick(){
//update internal time-keeping state
//...
Notify();
}
DigitalClock继承Widget和Observer，实现观察者实例。构造函数中初始化目标实现类ClockTimer，并订阅当前观察者对象；析构函数中取消订阅当前观察者对象；Update函数是观察者基类纯虚函数的真正实现，当目标ClockTimer更新，调用Notify时，会调用到当前对象Update函数，在Update函数中再调用Draw更新时钟界面显示。
class DigitalClock::public Widget,public Observer{
public:
DigitalClock(ClockTimer *);
virtual ~DigitalClock();
virtual void Update(Subject *);
//overrides Observer operation
virtual void Draw();
//overrides Widget operation;
//defines how to draw the digital clock
private:
ClockTimer* _subject;
};
DigitalClock::DigitalClock(ClockTimer *s){
_subject = s;
_subject->Attach(this);
}
DigitalClock::~DigitalClock(){
_subject->Detach(this);
}
void DigitalClock::Update(Subject * theChangedSubject){
if(theChangedSubject == _subject){
Draw();
}
}
void DigitalClock::Draw(){
//get the new values from the subject
int hour = _subject->GetHour();
int minute = _subject->GetMinute();
//etc.
//draw the digital clock
}
有了上述观察者和目标的实现类后，就能实现基于观察者设计模式的数字时钟实现，code为：
ClockTimer *timer = new ClockTimer;//新建目标对象
DigitalClock *digitalClock = new DigitalClock(timer);//新建观察者对象并订阅ClockTimer目标对象
上例是目标-观察者一 一对应的示例，比如实现多个相同时间的数字时钟，这时会用到单目标-多观察者模型：
ClockTimer *timer = new ClockTimer;
DigitalClock *digitalClock1 = new DigitalClock(timer);//Observer 1
DigitalClock *digitalClock2 = new DigitalClock(timer);//Observer 2
.
.
.
DigitalClock *digitalClockn = new DigitalClock(timer);//Observer n
当要实现监听多个端口的TCP连接的程序，这时会用到多目标-单观察者模型，需要在上ClockTimer和DigitalClock的基础上稍作修改，将观察者类中的目标用二维指针来存储目标对象，目标类、观察者类以及应用代码如下：
目标类：
class ClientTCPConnect::public Subject{
public:
TcpConnect();
virtual void OnReceivedData();//Received Data
virtual void GetData();
};
void ClientTCPConnect::OnReceivedData(){
//...
Notify();
}
void ClientTCPConnect::GetData(){
//Get TCP Data
}
观察者类：
ServerTCPConnect构造函数中传入目标者类的指针和大小，并订阅所有目标者类。
class ServerTCPConnect::public Observer{
public:
ServerTCPConnect(ClientTCPConnect **, int size);
virtual ~ServerTCPConnect();
virtual void Update(Subject *);
//overrides Observer operation
virtual void DealClientConnect(Subject *);
private:
ClientTCPConnect **_sbuject;
int _size;
};
ServerTCPConnect::ServerTCPConnect(ClientTCPConnect**s, int size){
_subject = s;
for(int i = ; i < _size; i++){
_subject[i]->Attach(this);
}
}
ServerTCPConnect::~ServerTCPConnect(){
for(int i = ; i < _size; i++){
_subject[i]->Detach(this);
}
}
void ServerTCPConnect::Update(Subject * theChangedSubject){
for(int i = ; i < _size; i++){
if(theChangedSubject == _subject[i]){
DealClientConnect(_subject[i]);
}
}
}
void ServerTCPConnect::DealClientConnect(Subject *s){
ClientTCPConnect *tcp = (ClientTCPConnect *)s;
tcp->GetData();//deal with TCP Data
}
应用：
int n=10;
ClientTCPConnect **ClientConnect = new ClientTCPConnect*[n];
for(int i = ; i < n; i++){
ClientConnect[i] = new ClientTCPConnect;
}
ServerTCPConnect *serverConnect = new ServerTCPConnect(ClientConnect, n);
再复杂的就是多目标-多观察者模型，可由上多目标-单观察者和单目标-多观察者模型组合而成。
int n = ;
ClientTCPConnect **ClientConnect = new ClientTCPConnect*[n];
for(int i = ; i < n; i++){
ClientConnect[i] = new ClientTCPConnect;
}
int m = ;
ServerTCPConnect **ServerConnect = new ServerTCPConnect*[m];
for(int j = ; i < m; j++){
ServerConnect[i] = new ServerTCPConnect(ClientConnect, n);
}
上面基本上都是相同的观察者和目标类，那么目标和观察者为不同的类时，该如何组合成多目标——多观察者的实例呢？
目标类ClientTCPConnect，ClientTCPConnect1，、、、，ClientTCPConnect_n的实现：
class ClientTCPConnect::public Subject{
public:
ClientTCPConnect();
virtual void OnReceivedData();//Received Data
virtual void GetData();
};
void ClientTCPConnect::OnReceivedData(){
//...
Notify();
}
void ClientTCPConnect::GetData(){
//Get TCP Data
}
.
.
.
class ClientTCPConnect_n::public Subject{
public:
ClientTCPConnect_n();
virtual void OnReceivedData_n();//Received Data
virtual void GetData_n();
};
void ClientTCPConnect_n::OnReceivedData_n(){
//...
Notify();
}
void ClientTCPConnect_n::GetData_n(){
//Get TCP Data
}
观察者类ServerTCPConnect，ServerTCPConnect1，、、、，ServerTCPConnect_m的实现：
class ServerTCPConnect::public Observer{
public:
ServerTCPConnect(Subject **, int size);
virtual ~ServerTCPConnect();
virtual void Update(Subject *);
//overrides Observer operation
virtual void DealClientConnect(Subject *);
private:
Subject **_subject;
ClientTCPConnect_k *_subject_k;
.
.
.
ClientTCPConnect_l *_subject_l;
int _size;
};
ServerTCPConnect::ServerTCPConnect(Subject **s, int size){
_subject = s;
_subject_k = (ClientTCPConnect_k*)_subject[k];
_subject_k->Attach(this);
.
.
.
_subject_l = (ClientTCPConnect_l*)_subject[l];
_subject_l->Attach(this);
}
ServerTCPConnect::~ServerTCPConnect(){
_subject_k->Detach(this);
.
.
.
_subject_l->Detach(this);
}
void ServerTCPConnect::Update(Subject * theChangedSubject){
for(int i = ; i < _size; i++){
if(theChangedSubject == _subject[i]){
DealClientConnect(_subject[i]);
}
}
}
void ServerTCPConnect::DealClientConnect(Subject *s){
if(ClientTCPConnect *tcp = dynamic_cast<ClientTCPConnect*>(s)){
tcp->GetData();//deal with TCP Data
...
}
.
.
.
else if(ClientTCPConnect_n *tcp = dynamic_cast<ClientTCPConnect_n*>(s)){
tcp->GetData_n();//deal with TCP Data
...
}
}
.
.
.
class ServerTCPConnect_m::public Observer{
public:
ServerTCPConnect_m(Subject **, int size);
virtual ~ServerTCPConnect_m();
virtual void Update(Subject *);
//overrides Observer operation
virtual void DealClientConnect_m(Subject *);
private:
Subject **_subject;
ClientTCPConnect_k *_subject_k;
.
.
.
ClientTCPConnect_l *_subject_l;
int _size;
};
ServerTCPConnect_m::ServerTCPConnect_m(Subject **s, int size){
_subject = s;
_subject_k = (ClientTCPConnect_k*)_subject[k];
_subject_k->Attach(this);
.
.
.
_subject_l = (ClientTCPConnect_l*)_subject[l];
_subject_l->Attach(this);
}
ServerTCPConnect_m::~ServerTCPConnect_m(){
_subject_k->Detach(this);
.
.
.
_subject_l->Detach(this);
}
void ServerTCPConnect_m::Update(Subject * theChangedSubject){
for(int i = ; i < _size; i++){
if(theChangedSubject == _subject[i]){
DealClientConnect_m(_subject[i]);
}
}
}
void ServerTCPConnect_m::DealClientConnect_m(Subject *s){
if(ClientTCPConnect *tcp = dynamic_cast<ClientTCPConnect*>(s)){
tcp->GetData();//deal with TCP Data
...
}
.
.
.
else if(ClientTCPConnect_n *tcp = dynamic_cast<ClientTCPConnect_n*>(s)){
tcp->GetData_n();//deal with TCP Data
...
}
}
观察者模式模型图
说了这么多，有时不如一张图来的直接，观察者模式可以用下UML图来表示，清晰明了！
观察者模式UML图b)
著名的MVC(Model/View/Controller)模式也是基于OBSERVER设计模式的，Model类担任目标的角色，而View是观察者的基类，Controller用于控制应用程序的流程，它处理事件并作出响应。“事件”包括用户的行为和数据 Model 上的改变。
MVC组件之间的典型合作c)
观察者模式的优点是只要订阅/登记了之后，当目标改变时，观察者能自动更新。
参考资料：
a) 《设计模式：可复用面向对象软件的基础》