20 行为型模式-----观察者模式

模式动机(Observer Pattern)：将数据的存储与显示进行分离设计，能够很好地降低模块直接的耦合性。但是我们在后台更新数据时总希望前台的显示也做出相应的变化，观察者模式很好地解决了这个问题。

观察者模式定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动更新状态，即对于一份后台数据，可以存在多个显示器负责显示并同时接收后台数据变更的通知。

观察者模式包含如下参与者：

Subject:

1> 可以有任意多个观察者同时观察同一目标

2> 可以添加观察者、删除观察者

Observer:

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

ConcreteSubject:

1> 将当前状态subjectState存到具体观察者ConcreteObserver中

2>  当状态发生改变时，及时通知各个观察者更新状态

ConcreteObserver:

1> 维护一个指向ConcreteSubject对象的指针subject

2> 存储有关状态observerState，该状态应该与具体目标的状态subjectState保持一致

 

当ConcreteSubject中的状态发生改变时，其会通知ConcreteObserver更新状态以保持状态的一致性。一个目标可以存在任意个观察者对象，一旦目标的状态发生改变，所有的观察者都会接到通知，但是目标对象可以不关心到底谁是它的观察者，其只需要调用Notify()就可以了。

 

模式结构图：

 

模式代码：

bt_观察者模式.h：

#ifndef OP_H
#define OP_H
#include <iostream>
#include <list>
using namespace std;

/*
    抽象观察者：
    1> 为那些在目标发生改变时需要得到通知的对象定义一个更新接口
*/
class Subject;
class Observer
{
public:
    virtual ~Observer(){ }
    virtual void Update() = 0;
};

/*
    抽象目标：
    1> 可以有任意多个观察者同时观察同一目标
    2> 可以添加观察者、删除观察者
*/
class Subject
{
public:
    Subject(){ observers = new list<Observer*>; }
    virtual ~Subject(){ delete observers; }
    void Attach(Observer* obv)
    {
        cout << "添加具体观察者" << endl;
        observers->insert(observers->end(), obv);
    }
    void Detach(Observer* obv)
    {
        cout << "删除具体观察者" << endl;
        delete obv;
        observers->remove(obv);
    }
    void Notify()
    {
        cout << "通知具体观察者更新状态->" << endl;
        list<Observer*>::iterator iter;
        for(iter = observers->begin(); iter != observers->end(); iter++)
        {
            (*iter)->Update();
        }
    }

private:
    list<Observer*>* observers;
};

/*
    具体目标：
    1> 将当前状态subjectState存到具体观察者ConcreteObserver中
    2> 当状态发生改变时，及时通知各个观察者更新状态
*/
class ConcreteSubject : public Subject
{
public:
    int GetState(){ return subjectState; }
    void SetState(int s)
    {
        subjectState = s;
        Notify();　　　　　　// 通知所有观察者更新状态
    }

private:
    int subjectState;
};
/*
    具体观察者：
    1> 维护一个指向ConcreteSubject对象的指针subject
    2> 存储有关状态observerState，该状态应该与具体目标的状态subjectState保持一致
*/
class ConcreteObserver : public Observer
{
public:
    ConcreteObserver(ConcreteSubject* cs, int state) : subject(cs), observerState(state){}
    virtual void Update()
    {
        cout << "->具体观察者更新状态" << endl;
        cout << "更新前状态为：" << observerState << endl;
        observerState = subject->GetState();
        cout << "更新后状态为：" << observerState << endl;
    }

private:
    ConcreteSubject* subject;
    int observerState;
};

#endif // OP_H

测试用例.cpp:

#include "bt_观察者模式.h"

int main()
{

    cout << "***** 观察者模式测试 *****" << endl;
    ConcreteSubject* cs = new ConcreteSubject;
    Observer* observer1 = new ConcreteObserver(cs, 6666);
    Observer* observer2 = new ConcreteObserver(cs, 7777);
    cs->Attach(observer1);　　// 注册观察者
11     cs->Attach(observer2);    // 注册观察者
12     cs->SetState(8888);

　　　　　　　　　　　　　　　　// cs->Notify();     // 由客户调用Notify

    delete observer2;
    delete observer1;
    delete cs;

    return 0;
}

模式分析：

：： 观察者模式将众多观察者和其依赖的具体目标进行解耦，使得每个目标仅知道存在观察者，但是不知道具体观察者是什么类型的。

：： 目标发送通知时使用广播方式，凡是被登记过的观察者都会接收到并及时更新状态。

：： Notify()函数由谁来调用呢？

如果是由具体目标对象调用Notify()，那么必须每改变一次状态，就调用一次Notify()。但是，如果让客户负责调用Notify()，虽然可以对于多次改变只调用一次Notify()，但是可能容易忘记调用，导致丢失状态。上例中就是由具体目标负责调用Notify的例子，如下所示为由客户调用Notify()的例子：

在ConcreteSubject::SetState(int s)中去掉Notify()：

void SetState(int s)

{

    subjectState = s;

}

主程序中增加cs->Notify()语句即可，结果和上述完全相同。

：： 当然也可以扩展目标的注册接口，使得不同类型的观察者只对特定类型的事件感兴趣，这样可以提高观察者更新状态的效率。当一种事件发生，目标仅通知那些注册为对该类事件感兴趣的观察者。

：： 如果依赖关系比较复杂，比如一个观察者依赖多个具体目标，而每个具体目标又对应多个观察者，这种多对多的依赖关系可以由一个专门的中介者来处理。一般而言，这种类型的中介者只应该存在唯一实例，因此最好用单例来设计它。