设计模式笔记--行为型模式之七Observer--观察者

意图：

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这一模式中的关键对象是目标和观察者。这种交互也称为发布订阅。

适用性：

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

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

3当一个对象必须通知其他对象，而它又不能假定其他对象是谁，即不希望这些对象是紧耦合的。

效果：

1目标和观察者之间的抽象耦合

2支持广播通信

3意外的更新

实现：

1创建目标到其观察之者间的映射，最简单的方法是显式的在目标中保存对他们的引用。或者用关联查找机制来维护目标到观察者的映射。

2观察多个目标

3谁触发更新

A由目标对象的状态设定操作在改变目标对象的状态后自动调用notify

B让客户负责在适当的时候调用Notify

4对已删除目标的悬挂引用，当一个目标被删除时，让它通知它的观察者将对该目标的引用复位。

5在发出通知前确保目标的状态自身是一致的

6 显式的指定兴趣的改变。 可以扩展注册的接口，让各观察者注册为仅对特定事件感兴趣，以提高更新效率

7如果目标和观察者之间的依赖关系特别复杂，需要一个ChangeManager

来维护，可以有Mediator中介者来实现。

 

 

The sample code is as below:

 

Observer.h

1. #include <list>
2. #include <iterator>
3. #include <iostream>
4. using namespace std;
5. class Subject;
7. class Observer
8. {
9. public:
10.     virtual ~Observer(){cout<<"An observer is destoryed"<<endl;}
11.     virtual void Update(Subject* theChangedSubject) = 0;
12. protected:
13.     Observer() {cout<<"An observer is created"<<endl;}
14. };
16. class Subject
17. {
18. public:
19.     virtual ~Subject() {cout<<"A subjct is destroyed"<<endl; }
20.     virtual void Attach(Observer*);
21.     virtual void Detach(Observer*);
22.     virtual void Notify();
23. protected:
24.     Subject() {cout<<"A subjct is created"<<endl;}
25. private:
26.     list<Observer*> _observers;
27. };
30. class ClockTimer:public Subject
31. {
32. public:
33.     ClockTimer(){cout<<"A clock timer is created"<<endl;}
34.     void Tick() {Notify();}
35. };
37. class DigitalClock: public Observer
38. {
39. public:
40.     DigitalClock(ClockTimer* s);
41.     virtual ~DigitalClock();
42.     virtual void Update(Subject *);
43.     virtual void Draw();
44. private:
45.     ClockTimer* _subject;
46. };
49. class AnalogClock: public Observer
50. {
51. public:
52.     AnalogClock(ClockTimer* s);
54.     virtual ~AnalogClock();
55.     virtual void Update(Subject *);
56.     virtual void Draw();
57. private:
58.     ClockTimer* _subject;
59. };

Observer.cpp

1. #include <list>
3. #include <iostream>
4. using namespace std;
5. #include "Observer.h"
6. void Observer::Update(Subject * theChangedSubject)
7. {
8.     cout<<"The Subject is changed"<<endl;
9. }
10. void Subject::Attach(Observer* o)
11. {
12.     //_observers->push_back(o);
13.     _observers.push_back(o);
14.     
15. }
17. void Subject::Detach(Observer* o)
18. {
19.     //_observers->remove(o);
20.     _observers.remove(o);
21. }
22. void Subject::Notify()
23. {
24.     for(list<Observer*>::iterator ixx= _observers.begin(); ixx != _observers.end();++ixx) 
25.     {
26.       (*ixx)->Update(this);
27.       
28.     }
30. }
31. DigitalClock::DigitalClock(ClockTimer* s)
32. {
33.     _subject = s;
34.     _subject->Attach(this);
35. }
36. DigitalClock::~DigitalClock()
37. {
38.     _subject->Detach(this);
39. }
40. void DigitalClock::Update(Subject* theChangedSubject)
41. {
42.     if (theChangedSubject == _subject)
43.     {
44.         Draw();
45.     }
46. }
47. void DigitalClock::Draw()
48. {
49.     cout<<"Draw the time in Digital Clock"<<endl;
50. }
51. AnalogClock::AnalogClock(ClockTimer* s)
52. {
53.     _subject = s;
54.     _subject->Attach(this);
55. }
56. AnalogClock::~AnalogClock()
57. {
58.     _subject->Detach(this);
59. }
60. void AnalogClock::Update(Subject* theChangedSubject)
61. {
62.     if (theChangedSubject == _subject)
63.     {
64.         Draw();
65.     }
66. }
67. void AnalogClock::Draw()
68. {
69.     cout<<"Draw the time in Analog Clock"<<endl;
70. }

 

main.cpp

1. #include<iostream>
2. #include "Observer.h"
3. using namespace std;
4. int main()
5. {
6.     ClockTimer* timer = new ClockTimer();
8.     AnalogClock* analogClock = new AnalogClock(timer);
9.     DigitalClock* digitalClock = new DigitalClock(timer);
10.     timer->Notify();
12.     return 0;
13. }