观察者模式

    观察者模式的意图是：定义对象间的一种关系，当一个对象的状态发生变化时，所有依赖于它的对象都能得到通知。

    你可以考虑这样一种应用，当一个论坛注册了个新用户后，论坛程序自动发一个站内欢迎消息和email。以后可能还有需求说同时也用手机发一条短信等等。在这里面，新用户是一个对象，发站内欢迎消息是一个对象，发email也是一个对象，还有发手机短信也可以是个对象。当新用户注册时（状态改变），其它依赖于它的对象都得到通知（发欢迎消息、email、手机短信等对象得到通知并执行相应动作）。

    观察者模式可以用来实现这种应用，并且可以适应不断变化的需求。如有新的对象需要被通知，只需增加新的观察者而不必改动原来的代码。下面看下具体的代码：

 

//----------------------------future.h开始----------------------------------
#ifndef FUTURE_H
#define FUTURE_H

#include <list>
using namespace std;

#include "mutex.h"

template<typename T>
class CFuture;

template<typename T>
class CObserver;

template<typename T>
class CFuture
...{
private:
//声明operator=和拷贝构造为private，以阻止CFuture对象之间的赋值
void operator = ( const CFuture<T> &r )
...{
}
CFuture(const CFuture<T> &r )
...{
}
public:
CFuture() : m_pValue(NULL)
...{
}

virtual ~CFuture()
...{
   delete m_pValue;
}

int Attach( CObserver<T> *pObserver )
...{//增加一个观察者
   if( NULL == pObserver )
   ...{
    return -1;
   }

   AUTO_GUARD( g, ThreadMutex, m_lock );

   m_ObserverPtrList.push_back( pObserver );

   if( this->m_pValue )
   ...{
    pObserver->Update( *this );
   }

   return 0;
}

int Detach( CObserver<T> *pObserver )
...{//解除一个观察者
   AUTO_GUARD( g, ThreadMutex, m_lock );

   m_ObserverPtrList.remove( pObserver );

   return 0;
}

int Set( const T & r )
...{//设置值
   if( NULL == this->m_pValue )
   ...{
    AUTO_GUARD( g, ThreadMutex, m_lock );

    if( NULL == this->m_pValue )
    ...{
     this->m_pValue = new T(r);
    }

    if( this->m_pValue )
    ...{//通知列表中的所有观察者
     list<OBSERVER_T *>::iterator it = m_ObserverPtrList.begin();
     for( ; it != m_ObserverPtrList.end(); it++ )
     ...{
      OBSERVER_T *pObserver = *it;
      pObserver->Update( *this );     
     }

     return 0;
    }   
   }

   return -1;
}

int Get( T & r ) const
...{//获取值
   if( !this->IsReady() )
   ...{
    return -1;
   }
   r = *m_pValue;
   return 0;
}

bool IsReady() const
...{//判断值是否已设置
   return ( m_pValue != NULL );
}

private:
typedef CObserver<T> OBSERVER_T;

private:
T * m_pValue;        //对象内部的值
ThreadMutex m_lock; //访问对象内部资源的锁
list<OBSERVER_T *> m_ObserverPtrList; //观察者列表
};

template<typename T>
class CObserver
...{//观察者接口
public:
CObserver()
...{
}
virtual ~CObserver()
...{
}
//观察者被通知的接口
virtual void Update( const CFuture<T> &fu ) = 0;
};

#endif
//----------------------------future.h开始----------------------------------

//----------------------------主程序文件observer.cpp开始----------------------------------
#include "future.h"

#include <iostream>
#include <string>
using namespace std;

class CMyObserverA : public CObserver<string>
...{//观察者A
public:
CMyObserverA()
...{
}
virtual ~CMyObserverA()
...{
}

virtual void Update( const CFuture<string> &fu )
...{//观察者A被通知
   string value;
   fu.Get( value );
   cout << "call CMyObserverA when future set to: " << value << endl;
}
};

class CMyObserverB : public CObserver<string>
...{//观察者B
public:
CMyObserverB()
...{
}
virtual ~CMyObserverB()
...{
}

virtual void Update( const CFuture<string> &fu )
...{//观察者B被通知
   string value;
   fu.Get( value );
   cout << "call CMyObserverB when future set to: " << value << endl;
}
};

int _tmain(int argc, _TCHAR* argv[])
...{
CFuture<string> myfu;
CMyObserverA myoba;
CMyObserverB myobb;

myfu.Attach( &myoba );
myfu.Attach( &myobb );

myfu.Set( "123456" );


return 0;
}
//----------------------------主程序文件observer.cpp结束----------------------------------

    如代码所示，CFuture是个状态会被改变的类，CObserver是所有观察者的公共接口，可以将多个CObserver观察者attach到 CFuture对象，这样当CFuture对象状态改变时（Set被调用），attach到该对象的观察者就会得到通知(Update被调用)。代码很简单，就不多做解释了，future.h中用到的mutex.h在另一篇文章“定界加锁模式”中有。