观察者模式

【1】什么是观察者模式？

观察者模式，定义一种一对多的依赖关系，多个观察者对象同时监听某一个主题对象。

当这个主题对象状态上发生变化时，会通知所有观察者对象，他们能够自动更新自己，随主题对象状态改变做出对应的行为表现。

【2】观察者模式代码示例：

代码示例如下：

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

class Observer;

// 管理观察者的基类
class Subject
{
public:
    string action;   // 主题名称
protected:
    list<Observer*> observers;  // 观察者的容器

public:
    virtual void attach(Observer*) = 0;
    virtual void detach(Observer*) = 0;
    virtual void notify() = 0;
};

// 观察者基类
class Observer
{
protected:
    string name;
    Subject *sub;

public:
    Observer(string name, Subject *sub)
    {
        this->name = name;
        this->sub = sub;
    }
    string getName()
    {
        return name;
    }

    virtual void update() = 0;
};

// 炒股票（观察者其一）
class StockObserver : public Observer
{
public:
    StockObserver(string name, Subject *sub) : Observer(name, sub)
    {}

    void update();
};

void StockObserver::update()
{
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上关闭股票，装做很认真工作的样子！" << endl;
    }
}

// 看NBA比赛（观察者其一）
class NBAObserver : public Observer
{
public:
    NBAObserver(string name, Subject *sub) : Observer(name, sub)
    {}
    void update();
};

void NBAObserver::update()
{
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上关闭NBA，装做很认真工作的样子！" << endl;
    }
}

// 玩游戏（观察者其一）
class GameObserver : public Observer
{
public:
    GameObserver(string name, Subject *sub) : Observer(name, sub)
    {}

    void update();
};

void GameObserver::update()
{
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上退出游戏，装做很认真工作的样子！" << endl;
    }
}

// 管理观察者的实现类（作为被观察者）
class Secretary : public Subject
{
public:
    void attach(Observer *observer)
    {
        cout << "add: " << observer->getName() << endl;
        observers.push_back(observer);
    }

    void detach(Observer *observer)
    {
        list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            if ((*iter) == observer)
            {
                cout << "erase: " << observer->getName() << endl;
                observers.erase(iter++);
            }
            else
            {
                ++iter;
            }
        }
    }

    void notify()
    {
        list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            (*iter)->update();
            ++iter;
        }
    }
};


void main()
{
    Subject *pDwq = new Secretary();  // 主题对象，作为被观察者

    Observer *pXs = new NBAObserver("xiaoshuai", pDwq);  // 小帅，作为观察者（监听者）
    Observer *pZy = new GameObserver("zhuoyue", pDwq);  // 卓越，作为观察者（监听者）
    Observer *pLm = new StockObserver("liming", pDwq); // 李明，作为观察者（监听者）

    // 绑定观察者与被观察者
    cout << "登记监听者： " << endl;
    pDwq->attach(pXs);
    pDwq->attach(pZy);
    pDwq->attach(pLm);

    // 测试广播动作
    cout << endl << "测试广播动作效果： " << endl;
    cout << "发出动作1效果：去吃饭了！" << endl;
    pDwq->action = "去吃饭了！";
    pDwq->notify();

    cout << endl << "发出动作2效果：梁所长来了！" << endl;
    pDwq->action = "梁所长来了!";
    pDwq->notify();

    // 解除绑定监听
    cout << endl << "解除监听者： " << endl;
    pDwq->detach(pLm);
    pDwq->detach(pZy);
    pDwq->detach(pXs);

    delete pDwq;
    delete pXs;
    delete pZy;
    delete pLm;

    system("pause");
}

// run out:
/*
登记监听者：
add: xiaoshuai
add: zhuoyue
add: liming

测试广播动作效果：
发出动作1效果：去吃饭了！
xiaoshuai 收到消息：去吃饭了！
zhuoyue 收到消息：去吃饭了！
liming 收到消息：去吃饭了！

发出动作2效果：梁所长来了！
xiaoshuai 收到消息：梁所长来了!
我马上关闭NBA，装做很认真工作的样子！
zhuoyue 收到消息：梁所长来了!
我马上退出游戏，装做很认真工作的样子！
liming 收到消息：梁所长来了!
我马上关闭股票，装做很认真工作的样子！

解除监听者：
erase: liming
erase: zhuoyue
erase: xiaoshuai
请按任意键继续. . .

 【3】观察者模式的优缺点

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

第一、观察者模式在被观察者和观察者之间建立一个抽象的耦合。

　　被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。

　　被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。

　　由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。

第二、观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。

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

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

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

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

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

Good  Good  Study, Day  Day  Up.

顺序   选择   循环   总结