观察者模式,又叫做发布-订阅(Publish/Subscribe)模式
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使得它们能够自动更新自己。
观察者模式的动机
将一个系统分割成一系列相互协作的类有一个很不好的副作用,那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合,这样会
给维护、扩展和重用都带来不方便。而观察者模式的关键对象是主题Subject和观察者Observer,一个Subject可以有任意数目的依赖它的
Observer,一旦Subject的状态发生了改变,所有的Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者,
也就是说,具体观察者是谁,它根本不需要知道。而任何一个具体观察者不知道也不需要知道其他观察者的存在。
什么时候应该使用观察者模式
当一个对象的改变需要同时改变其他对象的时候。而且它不知道具体有多少对象有待改变时,应该考虑使用观察者模式。也可以理解为,当一个抽象模型有两
个方面,其中一方面依赖于另一方面,这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。总的来说,观察者模式所做的工作其实就
是在解除耦合。让耦合的双方都依赖于抽象,而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。
工程结构
(1)抽象通知者Subject.h
(2)抽象观察者Observer.h
(3)具体通知者ConcreteSubject.h
(4)具体观察者ConcreteObserver.h
(5)客户端类ObserverApp.cpp
(1)抽象通知者Subject.h
-
-
-
-
-
-
-
- #ifndef _SUBJECT_H_
- #define _SUBJECT_H_
-
- #include "Observer.h"
- #include
- #include
- #include
- using namespace std;
-
- class CSubject
- {
- public:
-
- virtual void Attach(CObserver* pObserver) = 0;
-
-
- virtual void Detach(CObserver* pObserver) = 0;
-
-
- virtual void Notify(void) = 0;
- };
-
- #endif _SUBJECT_H_
(2)抽象观察者Observer.h
-
-
-
-
-
- #ifndef _OBSERVER_H_
- #define _OBSERVER_H_
-
- class CObserver
- {
- public:
- virtual void Update() = 0;
- };
-
- #endif _OBSERVER_H_
(3)具体通知者ConcreteSubject.h
-
-
-
-
-
- #ifndef _CONCRETE_SUBJECT_H_
- #define _CONCRETE_SUBJECT_H_
-
- #include "Subject.h"
-
- class CConcreteSubject : public CSubject
- {
- public:
-
-
- void Attach(CObserver* pObserver)
- {
- m_listObservers.push_back(pObserver);
- }
-
-
- void Detach(CObserver* pObserver)
- {
- m_listObservers.remove(pObserver);
- }
-
-
- void Notify(void)
- {
- list::iterator lIter;
- for (lIter = m_listObservers.begin(); lIter != m_listObservers.end(); lIter++)
- {
- (*lIter)->Update();
- }
- }
-
- void SetState(const string& strState)
- {
- m_strSubjectState = strState;
- }
-
- string GetState(void)
- {
- return m_strSubjectState;
- }
-
- private:
- string m_strSubjectState;
- list m_listObservers;
- };
-
- #endif _CONCRETE_SUBJECT_H_
(4)具体观察者ConcreteObserver.h
-
-
-
-
-
-
- #ifndef _CONCRETE_OBSERVER_H_
- #define _CONCRETE_OBSERVER_H_
-
- #include "ConcreteSubject.h"
-
- class CConcreteObserver : public CObserver
- {
- public:
- CConcreteObserver(CConcreteSubject* pSubject, const string& strName)
- {
- m_pSubject = pSubject;
- m_strName = strName;
- }
-
- void Update(void)
- {
- if (NULL != m_pSubject)
- {
- m_strObserverState = m_pSubject->GetState();
- cout << "观察者【" << m_strName << "】的新通知:" << m_strObserverState << endl;
- }
- }
-
- CConcreteSubject* GetSubject(void)
- {
- return m_pSubject;
- }
-
- void SetSubject(CConcreteSubject* pSubject)
- {
- m_pSubject = pSubject;
- }
-
- private:
- string m_strName;
- string m_strObserverState;
- CConcreteSubject* m_pSubject;
- };
-
- #endif _CONCRETE_OBSERVER_H_
(5)客户端类ObserverApp.cpp
-
-
-
- #include "stdafx.h"
- #include "ConcreteSubject.h"
- #include "ConcreteObserver.h"
-
- void FreeMemory(void* Pointer)
- {
- if (NULL != Pointer)
- {
- free(Pointer);
- }
- }
-
- int _tmain(int argc, _TCHAR* argv[])
- {
- CConcreteSubject* pConcreteSubject = NULL;
- pConcreteSubject = new CConcreteSubject();
-
- CConcreteObserver* pConcreteObserver1 = NULL;
- pConcreteObserver1 = new CConcreteObserver(pConcreteSubject, "Alice");
-
- CConcreteObserver* pConcreteObserver2 = NULL;
- pConcreteObserver2 = new CConcreteObserver(pConcreteSubject, "Bob");
-
- CConcreteObserver* pConcreteObserver3 = NULL;
- pConcreteObserver3 = new CConcreteObserver(pConcreteSubject, "Carey");
-
- pConcreteSubject->Attach(pConcreteObserver1);
- pConcreteSubject->Attach(pConcreteObserver2);
- pConcreteSubject->Attach(pConcreteObserver3);
- pConcreteSubject->Detach(pConcreteObserver3);
- pConcreteSubject->SetState("快休息~");
- pConcreteSubject->Notify();
-
- system("pause");
- FreeMemory(pConcreteObserver1);
- FreeMemory(pConcreteObserver2);
- FreeMemory(pConcreteObserver3);
- FreeMemory(pConcreteSubject);
-
- return 0;
- }
观察者模式的不足
尽管已经用了依赖倒转原则,但是“抽象通知者”还是依赖“抽象观察者”,
也就是说,万一没有了抽象观察者这样的接口,通知的功能就完成不了。另外每个具体观察者,它不一定是“更新”的方法要调用。比如:我们的VS开发工具,当
我们调式程序时,希望是“工具箱”隐藏,“自动窗口”打开,这根本就不是同名的方法。这就是不足的地方。如果通知者和观察者之间根本就相互不知道,由客户
端来决定通知谁。
事件委托:
委托就是一种引用方法的类型。一旦为委托分配了方法,委托将与该方法具有
完全相同的行为。委托方法的使用可以像其他任何方法一样,具有参数和返回值。委托可以看做是对函数的抽象,是函数的“类”,委托的实例将代表一个具体的函
数。一个委托可以搭载多个方法,所有方法被依次唤起。可以使得委托对象所搭载的方法并不需要属于同一个类。委托对象所搭载的所有方法必须具有相同的原型和
形式,也就是拥有相同的参数列表和返回值类型。
工程结构
(1)通知者类
(2)观察者类
(3)客户端类
(1)通知者类
-
-
-
-
-
- #ifndef _CONCRETE_SUBJECT_H_
- #define _CONCRETE_SUBJECT_H_
-
- #include
- using namespace std;
-
- class Observer;
- class CSubject
- {
- public:
- void AddObserver(Observer* pOb, void (Observer::*pMemFunc)())
- {
- m_MapOb.insert(pairvoid (Observer::*)()>(pOb, pMemFunc));
- }
-
- void Notify(void)
- {
- ObIter Iter = m_MapOb.begin();
- for (; Iter != m_MapOb.end(); Iter++)
- {
- void (Observer::*pMemFunc)() = Iter->second;
- (Iter->first->*pMemFunc)();
- }
- }
-
- string GetSubject(void)
- {
- return m_strSubject;
- }
-
- void SetSubject(const string& strSubject)
- {
- m_strSubject = strSubject;
- }
-
- private:
- mapvoid (Observer::*)()> m_MapOb;
- typedef mapvoid (Observer::*)()>::iterator ObIter;
-
- string m_strSubject;
- };
-
- #endif _CONCRETE_SUBJECT_H_
(2)观察者类
-
-
-
-
- #ifndef _CONCRETE_OBSERVER_H_
- #define _CONCRETE_OBSERVER_H_
-
- #include
- #include
- using namespace std;
-
- class Observer
- {
-
- };
-
- class CSubject;
- class CObserverA : public Observer
- {
- public:
- CObserverA(const string& strName, CSubject* pSubject)
- {
- m_strName = strName;
- m_pSubject = pSubject;
- }
-
- void UpdateOfObserverA(void)
- {
- if (NULL != m_pSubject)
- {
- cout << m_pSubject->GetSubject() << m_strName << "别打魔兽争霸了" << endl;
- }
- }
-
- private:
- string m_strName;
- CSubject* m_pSubject;
- };
-
- class CObserverB : public Observer
- {
- public:
- CObserverB(const string& strName, CSubject* pSubject)
- {
- m_strName = strName;
- m_pSubject = pSubject;
- }
-
- void UpdateOfObserverB(void)
- {
- if (NULL != m_pSubject)
- {
- cout << m_pSubject->GetSubject() << m_strName << "别打魔兽世界了" << endl;
- }
- }
-
- private:
- string m_strName;
- CSubject* m_pSubject;
- };
-
- #endif _CONCRETE_OBSERVER_H_
(3)客户端类
-
-
-
- #include "stdafx.h"
- #include "Subject.h"
- #include "ConcreteObserver.h"
-
- void FreeMemory(void* Pointer)
- {
- if (NULL != Pointer)
- {
- free(Pointer);
- }
- }
-
-
- int _tmain(int argc, _TCHAR* argv[])
- {
- CSubject ObjBoss;
- CObserverA* pObA = NULL;
- pObA = new CObserverA("Alice", &ObjBoss);
- CObserverB* pObB = NULL;
- pObB = new CObserverB("Bob", &ObjBoss);
-
- ObjBoss.AddObserver(pObA, (void (Observer::*)())&CObserverA::UpdateOfObserverA);
- ObjBoss.AddObserver(pObB, (void (Observer::*)())&CObserverB::UpdateOfObserverB);
- ObjBoss.SetSubject("你妈喊你回家吃饭!");
- ObjBoss.Notify();
-
- system("pause");
- FreeMemory(pObB);
- FreeMemory(pObA);
-
- return 0;
- }
阅读(1077) | 评论(0) | 转发(0) |