Observer设计模式

Observer模式

一、Observer设计模式初步描述

1.1 问题

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

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

1.2 模式选择

Observer模式典型的结构图为：
　

图2-1：Observer Pattern结构图

这里的目标Subject提供依赖于它的观察者Observer的注册（Attach）和注销（Detach）操作，并且提供了使得依赖于它的所有观察者同步的操作（Notify）。观察者Observer则提供一个Update操作，注意这里的Observer的Update操作并不在Observer改变了Subject目标状态的时候就对自己进行更新，这个更新操作要延迟到Subject对象发出Notify通知所有Observer进行修改（调用Update）。

1.3 实现

1.3.1 完整代码示例（code）

Observer模式的实现有些特点，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用C++实现，并在VC 6.0下测试运行）。
　

代码片断1：Subject.h //Subject.h #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() = 0; protected:  Subject(); private:  list<Observer* >* _obvs; }; class ConcreteSubject:public Subject { public:  ConcreteSubject();  ~ConcreteSubject();  State GetState();  void SetState(const State& st); protected: private:  State _st; }; #endif //~_SUBJECT_H_

代码片断2：Subject.cpp //Subject.cpp #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() {  return _st; } void ConcreteSubject::SetState(const State& st) {  _st = st; }

代码片断3：Observer.h //Observer.h #ifndef _OBSERVER_H_ #define _OBSERVER_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_

代码片断4：Observer.cpp //Observer.cpp #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.... "<<_sub->GetState()<<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.... "<<_sub->GetState()<<endl; } void ConcreteObserverB::Update(Subject* sub) {  _st = sub->GetState();  PrintInfo(); }

代码片断5：main.cpp //main.cpp #include "Subject.h" #include "Observer.h" #include <iostream> using namespace std; int main(int argc,char* argv[]) {  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; }

1.3.2 代码说明

在Observer模式的实现中，Subject维护一个list作为存储其所有观察者的容器。每当调用Notify操作就遍历list中的Observer对象，并广播通知改变状态（调用Observer的Update操作）。目标的状态state可以由Subject自己改变（示例），也可以由Observer的某个操作引起state的改变（可调用Subject的SetState操作）。Notify操作可以由Subject目标主动广播（示例），也可以由Observer观察者来调用（因为Observer维护一个指向Subject的指针）。

运行示例程序，可以看到当Subject处于状态“old”时候，依赖于它的两个观察者都显示“old”，当目标状态改变为“new”的时候，依赖于它的两个观察者也都改变为“new”。

1.4 讨论

Observer是影响极为深远的模式之一，也是在大型系统开发过程中要用到的模式之一。除了MFC、Struts提供了MVC的实现框架，在Java语言中还提供了专门的接口实现Observer模式：通过专门的类Observable及Observer接口来实现MVC编程模式，其UML图可以表示为：

Java中实现MVC的UML图。

这里的Observer就是观察者，Observable则充当目标Subject的角色。

Observer模式也称为发布－订阅（publish-subscribe），目标就是通知的发布者，观察者则是通知的订阅者（接受通知）。

二、Observer的详细描述和代码具体实例

下面的代码实现都是基于C#的，如果要参看基于C++，就看上面的代码实例即可。

2.1  观察者（Observer）模式

观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作（Collaboration）。观察者模式是满足这一要求的各种设计方案中最重要的一种。

2.2  观察者模式的结构

观察者模式的类图如下：

 

可以看出，在这个观察者模式的实现里有下面这些角色：

• 抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。
• 抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。
• 具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。
• 具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。

2.3  观察者模式的示意性源代码

//  Observer pattern -- Structural example  
using  System;
using  System.Collections;

//  "Subject"
abstract   class  Subject
{
  // Fields
  private ArrayList observers = new ArrayList();

  // Methods
  public void Attach( Observer observer )
  {
    observers.Add( observer );
  }

  public void Detach( Observer observer )
  {
    observers.Remove( observer );
  }

  public void