《ASCE1885的设计模式》---观察者模式

观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。这一模式镇中关键对象是目标（subject）和观察者（observer）。一个目标可以有任意数目的依赖于它的观察者。一旦目标的状态发生改变，所有观察者都得到通知。作为对这个通知的响应，每个观察者都将查询目标以使其状态与目标的状态同步。这种交互又称为发布-订阅模式。目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。

观察者模式的适用情况如下：

1）当一个抽象模型有两个方面，其中一个方面依赖于另一个方面；将这两者封装在独立的对象总以使它们可以各自独立地改变和复用；

2）当一个对象的改变需要同时改变其他对象，而不知道具体有多少个对象有待改变；

3）当一个对象必须通知其他对象，而它又不能假定其他对象是谁。即我们不希望这些对象是紧密耦合的。

观察者模式结构图如下：

观察者模式涉及到：

1）目标Subject：

目标知道它的观察者，可以有任意多个观察者观察同一个目标；提供注册和删除观察者对象的接口；

2）观察者Observer：

为那些在目标发生改变时需获得通知的对象定义一个更新接口；

3）具体目标ConcreteSubject：

将有关状态存入各ConcreteObserver对象；当它的状态发生改变时，向它的各个观察者发出通知；

4）具体观察者ConcreteObserver：

维护一个指向ConcreteSubject对象的引用；存储有关状态，这些状态应与目标的状态保持一致；实现Observer的更新接口以使自身状态与目标的状态保持一致；

实现：

观察者接口：

class Subject;
class Observer
{
public:
         virtual ~Observer();
         virtual void Update(Subject* m_subject) = 0;
protected:
         Observer();
};

这种实现方式支持一个观察者有多个目标，当观察者观察多个目标时，作为参数传递给Update操作的目标让观察者可以判定是哪一个目标发生了改变。

目标接口：

class Subject
{
public:
         virtual ~Subject();
         virtual void Attach(Observer*);
         virtual void Detach(Observer*);
         virtual void Notify();
protected:
         Subject();
private:
         std::list<Observer*> *_observers;
};
 
Subject::Subject()
{
         //记得使用前初始化
         _observers = new std::list<Observer*>;
}
 
void Subject::Attach(Observer* observer)
{
         _observers->push_back(observer);
}
 
void Subject::Detach(Observer* observer)
{
         if(observer != NULL)
                   _observers->remove(observer);
}
 
void Subject::Notify()
{
         std::list<Observer*>::iterator it = _observers->begin();
         while(it != _observers->end())
         {
                   (*it)->Update(this);
                   ++it;
         }
}
 
下面的例子是从维基百科上得来的：
#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
 
// The Abstract Observer
class ObserverBoardInterface
{
public:
    virtual void update(float a,float b,float c) = 0;
};
 
// Abstract Interface for Displays
class DisplayBoardInterface
{
public:
    virtual void show() = 0;
};
 
// The Abstract Subject
class WeatherDataInterface
{
public:
    virtual void registerob(ObserverBoardInterface* ob) = 0;
    virtual void removeob(ObserverBoardInterface* ob) = 0;
    virtual void notifyOb() = 0;
};
 
// The Concrete Subject
class ParaWeatherData: public WeatherDataInterface
{
public:
    void SensorDataChange(float a,float b,float c)
    {
        m_humidity = a;
        m_temperature = b;
        m_pressure = c;
        notifyOb();
    }
 
    void registerob(ObserverBoardInterface* ob)
    {
        m_obs.push_back(ob);
    }
 
    void removeob(ObserverBoardInterface* ob)
    {
        m_obs.remove(ob);
    }
protected:
    void notifyOb()
    {
        list<ObserverBoardInterface*>::iterator pos = m_obs.begin();
        while (pos != m_obs.end())
        {
            ((ObserverBoardInterface* )(*pos))->update(m_humidity,m_temperature,m_pressure);
            (dynamic_cast<DisplayBoardInterface*>(*pos))->show();
            ++pos;
        }
    }
 
private:
    float        m_humidity;
    float        m_temperature;
    float        m_pressure;
    list<ObserverBoardInterface* > m_obs;
};
 
// A Concrete Observer
class CurrentConditionBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    CurrentConditionBoard(WeatherDataInterface& a):m_data(a)
    {
        m_data.registerob(this);
    }
    void show()
    {
        cout<<"_____CurrentConditionBoard_____"<<endl;
        cout<<"humidity: "<<m_h<<endl;
        cout<<"temperature: "<<m_t<<endl;
        cout<<"pressure: "<<m_p<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        m_h = h;
        m_t = t;
        m_p = p;
    }
 
private:
    float m_h;
    float m_t;
    float m_p;
    WeatherDataInterface& m_data;
};
 
// A Concrete Observer
class StatisticBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    StatisticBoard(WeatherDataInterface& a):m_maxt(-1000),m_mint(1000),m_avet(0),m_count(0),m_data(a)
    {
        m_data.registerob(this);
    }
 
    void show()
    {
        cout<<"________StatisticBoard_________"<<endl;
        cout<<"lowest  temperature: "<<m_mint<<endl;
        cout<<"highest temperature: "<<m_maxt<<endl;
        cout<<"average temperature: "<<m_avet<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        ++m_count;
        if (t>m_maxt)
        {
            m_maxt = t;
        }
        if (t<m_mint)
        {
            m_mint = t;
        }
        m_avet = (m_avet * (m_count-1) + t)/m_count;
    }

private:

float m_maxt;
    float  m_mint;
    float m_avet;
    int m_count;
    WeatherDataInterface& m_data;
};
 
 
int main(int argc, char *argv[])
{
 
    ParaWeatherData * wdata = new ParaWeatherData;
    CurrentConditionBoard* currentB = new CurrentConditionBoard(*wdata);
    StatisticBoard* statisticB = new StatisticBoard(*wdata);
 
    wdata->SensorDataChange(10.2, 28.2, 1001);
    wdata->SensorDataChange(12, 30.12, 1003);
    wdata->SensorDataChange(10.2, 26, 806);
    wdata->SensorDataChange(10.3, 35.9, 900);
 
    wdata->removeob(currentB);
 
    wdata->SensorDataChange(100, 40, 1900);  
 
    delete statisticB;
    delete currentB;
    delete wdata;
 
    return 0;
}