【转】设计模式之观察者模式

Observer模式应该可以说是应用最多、影响最广的模式之一，因为Observer的一个实例Model/View/Control(MVC)结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表现层的解耦。Observer模式要解决的问题为：建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，依赖这个“一”的多也能够同步改变。

在GOF的《设计模式：可复用面向对象软件的基础》一书中对观察者模式是这样说的：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。当一个对象发生了变化，关注它的对象就会得到通知；这种交互也称为发布-订阅（publish-subscribe）。目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者。

最常见的一个例子：对同一组数据进行统计分析时，我们希望能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。这些表示都依赖于同一组数据，我们需要当数据改变的时候，所有的统计显示都能够同时改变。Observer模式就是解决这一问题。

UML类图

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

Observer（观察者）
——为那些在目标发生改变时需获得通知的对象定义一个更新接口。

ConcreteSubject（具体目标）
——将有关状态存入各ConcreteObserver对象；
——当它的状态发生改变时，向它的各个观察者发出通知。

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

观察者模式按照以下方式进行协作：

　　1、当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时，它将通知它的各个观察者；

　　2、在得到一个具体目标的改变通知后，ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。

适用场合

在以下任一情况下都可以使用观察者模式：

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

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

　　3、当一个对象必须通知其它对象，而它又不能假定其它对象是谁；也就是说，你不希望这些对象是紧密耦合的。

代码实现

Observer.h

/**
* File name: Observer.h
* Date: 2017.10.11
* Description:  Define the observer
*/
#pragma once
#include <iostream>
#include <set>
#include <string>
using namespace std;
//抽象主题角色Subject
class CObservable;
//抽象观察者角色
class CObserver
{
public:
    CObserver() {};
    virtual ~CObserver() {};
    //当被观察者的目标发生变化时，通知调用该方法
    //来自被观察者pObs，扩展参数为pArg
    virtual void Update(CObservable* pObs, void* pArg = NULL) = 0;
};

//被观察者，即Subject
class CObservable
{
public:
    CObservable() : m_bChanged(false) {};
    virtual ~CObservable() {};
    void Attach(CObserver* pObs);            //注册观察者
    void Detach(CObserver* pObs);            //注销观察者
    void DetachAll();                        //注销所有观察者
    void Notify(void* pArg = NULL);            //若状态变化，则遍历观察者，逐个通知更新
    bool HasChanged();                        //测试目标状态是否变化
    int GetObserversCount();                //获取观察者数量
protected:
    void SetChanged();                        //设置状态变化!!!必须继承CObservable才能设置目标状态
    void ClearChanged();                    //初始化目标为未变化状态
private:
    bool m_bChanged;
    set<CObserver*> m_setObs;
};

void CObservable::Attach(CObserver* pObs)
{
    if (!pObs)
        return;
    m_setObs.insert(pObs);
}

void CObservable::Detach(CObserver* pObs)
{
    if (!pObs)
        return;
    m_setObs.erase(pObs);
}

void CObservable::DetachAll()
{
    m_setObs.clear();
}

void CObservable::SetChanged()
{
    m_bChanged = true;
}

void CObservable::ClearChanged()
{
    m_bChanged = false;
}

bool CObservable::HasChanged()
{
    return m_bChanged;
}

int CObservable::GetObserversCount()
{
    return m_setObs.size();
}

void CObservable::Notify(void* pArg)
{
    if (!HasChanged())
        return;
    cout << "notify observers..." << endl;
    ClearChanged();
    set<CObserver*>::iterator itr = m_setObs.begin();
    for (; itr != m_setObs.end(); itr++)
    {
        (*itr)->Update(this, pArg);
    }
}

//具体主题角色
//bloger是发布者，即被观察者（subject）
class CBloger : public CObservable
{
public:
    void Publish(const string &strContent)
    {
        cout << "bloger publish, content: " << strContent << endl;
        SetChanged();
        Notify(const_cast<char*>(strContent.c_str()));
    }
};

//portal是发布者，即被观察者（subject）
class CPortal : public CObservable
{
public:
    void Publish(const string &strContent)
    {
        cout << "portal publish, content: " << strContent << endl;
        SetChanged();
        Notify(const_cast<char*>(strContent.c_str()));
    }
};

//RSS阅读者，观察者
class CRssReader : public CObserver
{
public:
    CRssReader(const string &strName) : m_strName(strName) {}
    virtual void Update(CObservable* pObs, void* pArg = NULL)
    {
        char* pContent = static_cast<char*>(pArg);
        //观察多个目标
        if (dynamic_cast<CBloger*>(pObs))
        {
            cout << m_strName << " updated from bloger, content: " << pContent << endl;
        }
        else if (dynamic_cast<CPortal*>(pObs))
        {
            cout << m_strName << " updated from portal, content: " << pContent << endl;
        }
    }
private:
    string m_strName;
};

//Mail阅读者，观察者
class CMailReader : public CObserver
{
public:
    CMailReader(const string &strName) : m_strName(strName) {}
    virtual void Update(CObservable* pObs, void* pArg = NULL)
    {
        char* pContent = static_cast<char*>(pArg);
        if (dynamic_cast<CBloger*>(pObs))
        {
            cout << m_strName << " updated from bloger, content: " << pContent << endl;
        }
        else if (dynamic_cast<CPortal*>(pObs))
        {
            cout << m_strName << " updated from portal, content: " << pContent << endl;
        }
    }
private:
    string m_strName;
};

main.cpp

/**
* File name: main.cpp
* Date: 2017.10.11
* Description:  An example of using observer
*/
#include "Observer.h"
int main()
{
    //目标（被观察者）
    CBloger* pBloger = new CBloger();
    CPortal* pPortal = new CPortal();

    //观察者 一个观察者可以观察多个目标
    CRssReader* pRssReader = new CRssReader("rss reader");
    CMailReader* pMailReader = new CMailReader("mail reader");
    pBloger->Attach(pRssReader);        //bloger注册观察者
    pBloger->Attach(pMailReader);        //bloger注册观察者
    pPortal->Attach(pRssReader);        //portal注册观察者
    pPortal->Attach(pMailReader);        //portal注册观察者
    //博客发布消息
    pBloger->Publish("blog shares pattren of design");
    cout << endl;

    //门户发布消息
    pPortal->Publish("portal shares pattern of design");
    cout << "
portal detached mail reader" << endl;

    pPortal->Detach(pMailReader);

    cout << "portal observers count:" << pPortal->GetObserversCount() << endl << endl;
    pPortal->Publish("portal shares pattern of design");

    system("pause");
    return 0;
}

vs2017运行结果

 

转自：

http://www.cnblogs.com/carsonzhu/p/5770253.html