功能

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

解决

• 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作
• 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
• 如何解决：使用面向对象技术，可以将这种依赖关系弱化
• 关键代码：在抽象类里有一个 ArrayList 存放观察者们

优缺点

• 优点：
  • 观察者和被观察者是抽象耦合的
  • 建立一套触发机制
• 缺点：
  • 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
  • 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃
  • 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化

应用场景

• 应用实例：拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。
• 使用场景：
  • 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用
  • 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度
  • 一个对象必须通知其他对象，而并不知道这些对象是谁
  • 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制
• 注意事项：
  • JAVA 中已经有了对观察者模式的支持类
  • 避免循环引用
  • 如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式

简单示例代码部分

Observer.hpp

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

class Observer;
class Subject{
public:
	virtual ~Subject(){}
	virtual void Attach(Observer* obv){
		_obvs->push_front(obv);
	}
	virtual void Detach(Observer* obv){
		if (obv != NULL) 
			_obvs->remove(obv);
	}
	virtual void Notify();
	virtual void SetState(const State& st) = 0; 
	virtual State GetState() = 0;
protected: 
	Subject(){
		_obvs = new list<Observer*>;
	}
private:
	list<Observer* >* _obvs;
};

class ConcreteSubject:public Subject {
public:
	ConcreteSubject(){
		_st='\0';
	}
	~ConcreteSubject(){}
	State GetState(){
		return _st;
	}
	void SetState(const State& st){
		_st=st;
	}
private:
	State _st; 
};


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

class ConcreteObserverA:public Observer {
public:
	virtual Subject* GetSubject(){
		return _sub;
	}
	ConcreteObserverA(Subject* sub){
		_sub=sub;
		_sub->Attach(this);
	}
	virtual ~ConcreteObserverA(){
		_sub->Detach(this); 
		if (_sub != 0)
			delete _sub;
	}
	//传入 Subject 作为参数，这样可以让一个 View 属于多个的 Subject。
	void Update(Subject* sub){
		_st = sub->GetState();
		PrintInfo();
	}
	void PrintInfo(){
		cout<<"ConcreteObserverA oberserver..."<<_sub->GetState()<<endl;
	}
private:
	Subject* _sub;
};

class ConcreteObserverB:public Observer {
public:
	virtual Subject* GetSubject(){
		return _sub;
	} 
	ConcreteObserverB(Subject* sub){
		_sub = sub;
		_sub->Attach(this);
	} 
	virtual ~ConcreteObserverB(){
		_sub->Detach(this); 
		if (_sub != 0){
			delete _sub;
		}
	}
//传入 Subject 作为参数，这样可以让一个 View 属于多个的 Subject。
	void Update(Subject* sub){
		_st = sub->GetState();
		PrintInfo();
	}
	void PrintInfo(){
		cout<<"ConcreteObserverB oberserver..."<<_sub->GetState()<<endl;
	}
private:
	Subject* _sub;
};


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

main.cpp

#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");
	sub->Notify();
	return 0; 
}