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 Notify()
  {
    foreach( Observer o in observers )
      o.Update();
  }
}

//  "ConcreteSubject"
class  ConcreteSubject : Subject
{
  // Fields
  private string subjectState;

  // Properties
  public string SubjectState
  {
    get{ return subjectState; }
    set{ subjectState = value; }
  }
}

//  "Observer"
abstract   class  Observer
{
  // Methods
  abstract public void Update();
}

//  "ConcreteObserver"
class  ConcreteObserver : Observer
{
  // Fields
  private string name;
  private string observerState;
  private ConcreteSubject subject;

  // Constructors
  public ConcreteObserver( ConcreteSubject subject,  
    string name )
  {
    this.subject = subject;
    this.name = name;
  }

  // Methods
  override public void Update()
  {
    observerState = subject.SubjectState;
    Console.WriteLine( "Observer {0}'s new state is {1}",
      name, observerState );
  }

  // Properties
  public ConcreteSubject Subject
  {
    get { return subject; }
    set { subject = value; }
  }
}

/// <summary>
/// Client test
/// </summary>
public   class  Client
{
  public static void Main( string[] args )
  {
    // Configure Observer structure
    ConcreteSubject s = new ConcreteSubject();
    s.Attach( new ConcreteObserver( s, "1" ) );
    s.Attach( new ConcreteObserver( s, "2" ) );
    s.Attach( new ConcreteObserver( s, "3" ) );

    // Change subject and notify observers
    s.SubjectState = "ABC";
    s.Notify();
  }
}

2.4  C#中的Delegate与Event

实际上在C#中实现Observer模式没有这么辛苦，.NET中提供了Delegate与Event机制，我们可以利用这种机制简化Observer模式。关于Delegate与Event的使用方法请参考相关文档。改进后的Observer模式实现如下：

//  Observer pattern -- Structural example  
using  System;

// Delegate
delegate   void  UpdateDelegate(); 

// Subject
class  Subject
{
  public event UpdateDelegate UpdateHandler;
  
  // Methods
  public void Attach( UpdateDelegate ud )
  {
    UpdateHandler += ud;
  }

  public void Detach( UpdateDelegate ud )
  {
    UpdateHandler -= ud;
  }
  
  public void Notify()
  {
    if(UpdateHandler != null) UpdateHandler();
  }

}

// ConcreteSubject
class  ConcreteSubject : Subject
{
  // Fields
  private string subjectState;

  // Properties
  public string SubjectState
  {
    get{ return subjectState; }
    set{ subjectState = value; }
  }
}

//  "ConcreteObserver"
class  ConcreteObserver
{
  // Fields
  private string name;
  private string observerState;
  private ConcreteSubject subject;

  // Constructors
  public ConcreteObserver( ConcreteSubject subject,  
    string name )
  {
    this.subject = subject;
    this.name = name;
  }

  // Methods
  public void Update()
  {
    observerState = subject.SubjectState;
    Console.WriteLine( "Observer {0}'s new state is {1}",
      name, observerState );
  }

  // Properties
  public ConcreteSubject Subject
  {
    get { return subject; }
    set { subject = value; }
  }
}

//  "ConcreteObserver"
class  AnotherObserver
{
  // Methods
  public void Show()
  {
    Console.WriteLine("AnotherObserver got an Notification!");
  }
}

public   class  Client
{ 
  public static void Main(string[] args)
  { 
    ConcreteSubject s = new ConcreteSubject();
    ConcreteObserver o1 = new ConcreteObserver(s, "1");
    ConcreteObserver o2 = new ConcreteObserver(s, "2");
    AnotherObserver o3 = new AnotherObserver();
    
    s.Attach(new UpdateDelegate(o1.Update));
    s.Attach(new UpdateDelegate(o2.Update));
    s.Attach(new UpdateDelegate(o3.Show));

    s.SubjectState = "ABC";
    s.Notify();

    Console.WriteLine("--------------------------");
    s.Detach(new UpdateDelegate(o1.Update));

    s.SubjectState = "DEF";
    s.Notify();
  }
}

其中，关键的代码如下：

delegate   void  UpdateDelegate(); 

定义一个Delegate，用来规范函数结构。不管是ConcreteObserver类的Update方法还是AnotherObserver类的Show方法都符合该Delegate。这不象用Observer接口来规范必须使用Update方法那么严格。只要符合Delegate所指定的方法结构的方法都可以在后面被事件所处理。

public   event  UpdateDelegate UpdateHandler;

定义一个事件，一旦触发，可以调用一组符合UpdateDelegate规范的方法。

   public   void  Attach( UpdateDelegate ud )
   {
    UpdateHandler += ud;
  }

订阅事件。只要是一个满足UpdateDelegate的方法，就可以进行订阅操作（如下所示）。

    s.Attach( new  UpdateDelegate(o1.Update));
    s.Attach( new  UpdateDelegate(o2.Update));
    s.Attach( new  UpdateDelegate(o3.Show));

在Notify方法中：

   public   void  Notify()
   {
    if(UpdateHandler != null) UpdateHandler();
  }

只要UpdateHandler != null（表示有订阅者），就可以触发事件（UpdateHandler()），所有的订阅者便会接到通知。

2.5  一个实际应用观察者模式的例子

该例子演示了注册的投资者在股票市场发生变化时，可以自动得到通知。该例子仍然使用的是传统的Observer处理手段，至于如何转换成Delegate与Event留给读者自己考虑。

//  Observer pattern -- Real World example  
using  System;
using  System.Collections;

//  "Subject"
abstract   class  Stock
{
  // Fields
  protected string symbol;
  protected double price;
  private ArrayList investors = new ArrayList();

  // Constructor
  public Stock( string symbol, double price )
  {
    this.symbol = symbol;
    this.price = price;
  }

  // Methods
  public void Attach( Investor investor )
  {
    investors.Add( investor );
  }

  public void Detach( Investor investor )
  {
    investors.Remove( investor );
  }

  public void Notify()
  {
    foreach( Investor i in investors )
      i.Update( this );
  }

  // Properties
  public double Price
  {
    get{ return price; }
    set
    {
      price = value;
      Notify(); 
    }
  }

  public string Symbol
  {
    get{ return symbol; }
    set{ symbol = value; }
  }
}

//  "ConcreteSubject"
class  IBM : Stock
{
  // Constructor
  public IBM( string symbol, double price )
    : base( symbol, price ) {}
}

//  "Observer"
interface  IInvestor
{
  // Methods
  void Update( Stock stock );
}

//  "ConcreteObserver"
class  Investor : IInvestor
{
  // Fields
  private string name;
  private string observerState;
  private Stock stock;

  // Constructors
  public Investor( string name )
  {
    this.name = name;
  }

  // Methods
  public void Update( Stock stock )
  {
    Console.WriteLine( "Notified investor {0} of {1}'s change to {2:C}", 
      name, stock.Symbol, stock.Price );
  }

  // Properties
  public Stock Stock
  {
    get{ return stock; }
    set{ stock = value; }
  }
}

/// <summary>
/// ObserverApp test
/// </summary>
public   class  ObserverApp
{
  public static void Main( string[] args )
  {
    // Create investors
    Investor s = new Investor( "Sorros" );
    Investor b = new Investor( "Berkshire" );

    // Create IBM stock and attach investors
    IBM ibm = new IBM( "IBM", 120.00 );
    ibm.Attach( s );
    ibm.Attach( b );

    // Change price, which notifies investors
    ibm.Price = 120.10;
    ibm.Price = 121.00;
    ibm.Price = 120.50;
    ibm.Price = 120.75;
  }
}

2.6  观察者模式的优缺点

Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。

但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。

观察者模式的效果有以下几个优点：

（1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

（2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。

观察者模式有下面的一些缺点：

（1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

（2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。

（3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

（4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。