[行为模式]head first 设计模式之观察者模式(observer)

怼烎@ 2022-04-17 02:25 170阅读 0赞

1 定义：  
观察者模式(有时又被称为发布/订阅模式)是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。  
\[color=red\]定义对象间的一种一对多的以来关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。  
别名：依赖(Dependennts),发布-订阅（Publish-Subscribe）\[/color\]  
  
2 设计原则  
\[size=medium\]\[color=red\]为了交互对象之间的松耦合设计而努力，简单点讲就是出版者+订阅者=观察者模式。\[/color\]\[/size\]  
  
3 参与类别  
参与本模式的各类别列出如下。成员函式以模拟的方式列出。  
3.1 抽象目标类别  
此抽象类别提供一个接口让观察者进行添附与解附作业。此类别内有个不公开的观察者串炼，并透过下列函式(方法)进行作业  
\[b\] 添附(Attach)：\[/b\]新增观察者到串炼内，以追踪目标物件的变化。  
\[b\]解附(Detach)：\[/b\]将已经存在的观察者从串炼中移除。  
\[b\]通知(Notify)：\[/b\]利用观察者所提供的更新函式来通知此目标已经产生变化。  
添附函式包涵了一个观察者物件参数。也许是观察者类别的虚拟函式(即更新函式)，或是在非面向对象的设定中所使用的函式指标(更广泛来讲，函式子或是函式物件)。  
  
3.2 目标类别  
此类别提供了观察者欲追踪的状态。也利用其源类别(例如前述的抽象目标类别)所提供的方法,来通知所有的观察者其状态已经更新。此类别拥有以下函式  
取得状态\[b\](GetState)：\[/b\]回传该目标物件的状态。  
  
3.3 抽象观察者接口  
抽象观察者类别是一个必须被实做的抽象类别。这个类别定义了所有观察者都拥有的更新用接口，此接口是用来接收目标类别所发出的更新通知。此类别含有以下函式  
更新(Update)：会被实做的一个抽象(虚拟)函式。  
  
3.4 观察者类别  
这个类别含有指向目标类别的参考(reference)，以接收来自目标类别的更新状态。此类别含有以下函式  
\[b\]更新(Update)：\[/b\]是前述抽象函式的实做。当这个函式被目标物件呼叫时，观察者物件将会呼叫目标物件的取得状态函式，来其所拥有的更新目标物件资讯。  
每个观察者类别都要实做它自己的更新函式，以应对状态更新的情形。  
当目标物件改变时，会通过呼叫它自己的通知函式来将通知送给每一个观察者物件，这个通知函式则会去呼叫已经添附在串炼内的观察者更新函式。通知与更新函式可能会有一些参数，好指明是目前目标物件内的何种改变。这么作将可增进观察者的效率(只更新那些改变部份的状态)。  
  
4 观察者模式的优点  
观察者与被观察者之间是属于轻度的关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。  
观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较令人担忧的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。  
  
\[img\]http://t25-1.yunpan.360.cn/p/800-600.fb8a80c738c77348b1976d0b0c7198c5c31578c9.83a2ab.jpg?t=a344bfb34b846467f2df389c48ad5ce8&d=20130821\[/img\]

#ifndef   OBSERVER_H
    #define   OBSERVER_H
    
    #include <iostream>
    #include <list>
    using namespace std;
    
    //观察者模式
    namespace Observer
    {
       
    
    //
    class Observer
    {
       
    public:
        virtual void update(float temp, float humidity, float pressure) = 0;
    };
    //
    typedef list<Observer*> ObserverList;
    
    class Subject
    {
       
    public:
        virtual void registerObserver(Observer* ob) = 0 ;
        virtual void removeObserver(Observer* ob) = 0;
        virtual void notifyObserver() = 0;
    };
    
    class WeatherData : public Subject
    {
       
    public:
        virtual void registerObserver(Observer* ob)
        {
       
            m_ObserverList.push_back(ob);
        }
    
        virtual void removeObserver(Observer* ob)
        {
       
            ObserverList::const_iterator itr = find(ob);
            if ( itr != m_ObserverList.end() )
            {
       
                m_ObserverList.erase(itr);
            }
        }
    
        virtual void notifyObserver()
        {
       
            ObserverList::const_iterator itr = m_ObserverList.begin();
            ObserverList::const_iterator end = m_ObserverList.end();
            for ( ; itr != end; ++itr)
            {
       
                if ( *itr != NULL)
                {
       
                    (*itr)->update(m_Tempperature, m_Humidity, m_Pressure);
                }
            }
        }
    
        void measurementsChanged()
        {
       
            notifyObserver();
        }
    
        void setMeasurements(float tempperature, float humidity, float pressure)
        {
       
            this->m_Tempperature = tempperature;
            this->m_Humidity     = humidity;
            this->m_Pressure     = pressure;
            measurementsChanged();
        }
    
    private:
        ObserverList::const_iterator find( const Observer* ob)
        {
       
            ObserverList::const_iterator itr = m_ObserverList.begin();
            ObserverList::const_iterator end = m_ObserverList.end();
            for ( ; itr != end; ++itr)
            {
       
                if ( *itr == ob)
                {
       
                    return itr;
                }
            }
    
            return end;
        }
    
    private:
        ObserverList m_ObserverList;
        float        m_Tempperature;
        float        m_Humidity;
        float        m_Pressure;
    };
    
    //
    class DisplayElement
    {
       
    public:
        virtual void display() = 0 ;
    };
    
    //
    class CurrentConditionDisplay : public Observer, public DisplayElement
    {
       
    public:
        CurrentConditionDisplay(Subject* weatherData)
            : m_Humidity(0),
            m_Tempperature(0.0f),
            m_WeatherData(NULL)
        {
       
            if (weatherData != NULL)
            {
       
                if (m_WeatherData!=NULL)
                {
       
                    delete m_WeatherData;
                    m_WeatherData = NULL;
                }
    
                this->m_WeatherData = weatherData;
                this->m_WeatherData->registerObserver(this);
            }
        }
        virtual ~CurrentConditionDisplay()
        {
       
            if (m_WeatherData != NULL)
            {
       
                delete m_WeatherData;
                m_WeatherData = NULL;
            }
        }
        virtual void update(float temp, float humidity, float pressure)
        {
       
            this->m_Tempperature = temp;
            this->m_Humidity     = humidity;
            display();
        }
    
        virtual void display()
        {
       
            cout << "Current conditions: " << m_Tempperature << "F degree and " << m_Humidity << "% humidity" <<endl;
        }
    
    private:
        float     m_Tempperature;
        float     m_Humidity;
        Subject*  m_WeatherData;
    };
    
    class WeatherStation
    {
       
    public:
        void run()
        {
       
            WeatherData* weatherData = new WeatherData();
    
            CurrentConditionDisplay* currentDisplay1 = new CurrentConditionDisplay(weatherData);
            CurrentConditionDisplay* currentDisplay2 = new CurrentConditionDisplay(weatherData);
            CurrentConditionDisplay* currentDisplay3 = new CurrentConditionDisplay(weatherData);
            //StatisticsDisplay* statisticsDisplay    = new StatisticsDisplay(weatherData);
            //ForecastDisplay* forecastDisplay    = new ForecastDisplay(weatherData);
    
            weatherData->setMeasurements(80, 65, 30.4f);
            weatherData->setMeasurements(82, 70, 29.2f);
            weatherData->setMeasurements(78, 90, 29.2f);
    
            if (weatherData != NULL)
            {
       
                delete weatherData;
            }
    
            if (currentDisplay1 != NULL)
            {
       
                delete currentDisplay1;
            }
    
            if (currentDisplay2 != NULL)
            {
       
                delete currentDisplay2;
            }
    
            if (currentDisplay3 != NULL)
            {
       
                delete currentDisplay3;
            }
        }
    };
    
    }//namespace Observer
    
    #endif