c++设计模式—观察者模式

Observer模式（观察者模式）应该可以说是应用最多、影响最广的模式之一。因为 Observer 的一个实例 Model/View/Control（ MVC） 结构在系统开发架构设计中有着很重要的地位和意义， MVC实现了业务逻辑和表示层的解耦。在 MFC 中， Doc/View（文档视图结构）提供了实现 MVC 的框架结构。在 Java 阵容中， Struts 则提供和 MFC 中 Doc/View 结构类似的实现 MVC 的框架。另外 Java 语言本身就提供了 Observer 模式的实现接口。当然， MVC 只是 Observer 模式的一个实例。 Observer 模式要解决的问题为： 建立一个一（ Subject）对多（ Observer） 的依赖关系， 并且做到当“一” 变化的时候， 依赖这个“一”的多也能够同步改变。
MVC模型

1.观察者模式

观察者模式定义了对象之间一对多的依赖关系，当对象改变时，依赖它的监听者也会随着改变。
适用情况：
（1）当一个抽象模型有两方面，其中一方面依赖于令一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
（2）当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
（3）当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
1. 观察者的UNL图

Subject（目标）
—目标知道它的观察者。可以有任意多个观察者观察同一个目标；
—提供注册和删除观察者对象的接口。
Observer（观察者）
—为那些在目标发生改变时需获得通知的对象定义一个更新接口。
ConcreteSubject（具体目标）
—将有关状态存入各ConcreteObserver对象；
—当它的状态发生改变时，向它的各个观察者发出通知。
ConcreteObserver（具体观察者）
—维护一个指向ConcreteSubject对象的引用；
—存储有关状态，这些状态应与目标的状态保持一致；
—实现Observer的更新接口以使自身状态与目标的状态保持一致。
观察者模式按照以下方式进行协作：
（1）当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时，它将通知它的各个观察者；
（2）在得到一个具体目标的改变通知后，ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。
3. 代码实现

class Listener
{
public:
    Listener(string name):_name(name){}
    virtual void handleMessage(int msgid)=0;
protected:
    string _name;
};
class Listener1 : public Listener
{
public:
    Listener1(string name):Listener(name){}
    void handleMessage(int msgid)
    {
        switch(msgid)
        {
        case 0:
            cout<<_name<<" recv 0 msg!"<<endl;
            break;
        case 1:
            cout<<_name<<" recv 1 msg!"<<endl;
            break;
        case 2:
            cout<<_name<<" recv 2 msg!"<<endl;
            break;
        default:
            cout<<_name<<" recv invalid msg!"<<endl;
            break;
        }
    }
};
class Listener2 : public Listener
{
public:
    Listener2(string name):Listener(name){}
    void handleMessage(int msgid)
    {
        switch(msgid)
        {
        case 0:
            cout<<_name<<" recv 0 msg!"<<endl;
            break;
        case 1:
            cout<<_name<<" recv 1 msg!"<<endl;
            break;
        default:
            cout<<_name<<" recv invalid msg!"<<endl;
            break;
        }
    }
};
class Listener3 : public Listener
{
public:
    Listener3(string name):Listener(name){}
    void handleMessage(int msgid)
    {
        switch(msgid)
        {
        case 1:
            cout<<_name<<" recv 1 msg!"<<endl;
            break;
        case 2:
            cout<<_name<<" recv 2 msg!"<<endl;
            break;
        default:
            cout<<_name<<" recv invalid msg!"<<endl;
            break;
        }
    }
};

class Observer
{
public:
    typedef map<int, list<Listener*>> _MAP;
    void registerListener(Listener *p, int msgid)
    {
        //lock
        // _obMap[msgid].push_back(p);
        _MAP::iterator it = _obMap.find(msgid);
        if(it == _obMap.end())
        {
            list<Listener*> mylist;
            mylist.push_front(p);
            _obMap.insert(make_pair(msgid, mylist));
        }
        else
        {
            it->second.push_front(p);
        }
        //unlock
    }
    void dispatchMessage(int msgid)
    {
        _MAP::iterator it = _obMap.find(msgid);
        if(it != _obMap.end())
        {
            list<Listener*>::iterator lit = it->second.begin();
            for(; lit != it->second.end(); ++lit)
            {
                (*lit)->handleMessage(msgid);
            }
        }
    }
private:
    map<int, list<Listener*>> _obMap;
};

int main()
{
    Listener *p1 = new Listener1("Listener1");
    Listener *p2 = new Listener2("Listener2");
    Listener *p3 = new Listener3("Listener3");

    Observer obser;
    obser.registerListener(p1, 0);
    obser.registerListener(p1, 1);
    obser.registerListener(p1, 2);
    obser.registerListener(p2, 0);
    obser.registerListener(p2, 1);
    obser.registerListener(p3, 1);
    obser.registerListener(p3, 2);

    int msgid = 0;
    while(true)
    {
        cout<<"msgid:";
        cin>>msgid;
        obser.dispatchMessage(msgid);
    }

    return 0;
}