我所理解的设计模式（C++实现）——观察者模式（Observer Pattern） (转)

概述：

        最近中国股市起起伏伏，当然了起伏就用商机，小明发现商机后果断想入市，买入了中国证券，他想在电脑客户端上，网页上，手机上，iPad上都可以查看到该证券的实时行情，这种情况下我们应该怎么设计我们的软件呢？我们可以这样：小明的所有客户端上都订阅中国证券这个股票，只要股票一有变化，所有的客户端都会被通知到并且被自动更新。

         这就是我们的观察者模式，她定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

类图与实例：

可以看出，在这个观察者模式的实现里有下面这些角色：

        抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。

        抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。

       具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。

        具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。       

       从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。

        这里我们提供一个简单化的实例：

[cpp]  view plain copy

1. #include <iostream>   
2. #include <vector>   
3. #include <string>   
4. using namespace std;  
5. class Secretary;  
6. // 看股票的同事类（观察对象，观察者）   
7. class StockObserver  
8. {  
9. public:  
10.     StockObserver(string strName, Secretary* strSub)  
11.     {  
12.         name = strName;  
13.         sub = strSub;  
14.     }  
15.   
16.     void Update();  
17.   
18. private:  
19.     string name;  
20.     Secretary* sub;  
21. };  
22.   
23. // 秘书类（主题对象，通知者）   
24. class Secretary  
25. {  
26.   
27. public:  
28.     string action;  
29.     void Add(StockObserver ob) { observers.push_back(ob); }  
30.     void Remove(int addIndex)  
31.     {  
32.         if(addIndex >=0 && addIndex < observers.size())  
33.         observers.erase(observers.begin() + addIndex);  
34.     }  
35.     void Notify()  
36.     {  
37.         vector<StockObserver>::iterator it;  
38.         for (it=observers.begin(); it!=observers.end(); ++it)  
39.         {  
40.             (*it).Update();  
41.         }  
42.     }  
43.   
44. private:  
45.     vector<StockObserver> observers;  
46. };  
47.   
48.   
49.   
50.   
51. void StockObserver::Update()  
52. {  
53.     cout << name << " : " << sub->action << ", begin to work" << endl;  
54. }  
55.   
56. int main()  
57. {  
58.     // 创建通知者   
59.     Secretary* p = new Secretary();  
60.   
61.     // 观察者   
62.     StockObserver* s1 = new StockObserver("Lazy", p);  
63.     StockObserver* s2 = new StockObserver("SnowFire", p);  
64.   
65.     // 加入通知队列   
66.     p->Add(*s1);  
67.     p->Add(*s2);  
68.   
69.     // 事件   
70.     p->action = "The boss is coming...";  
71.   
72.     // 通知   
73.     p->Notify();  
74.   
75.     // 动态删除   
76.     p->Remove(0);  
77.       
78.     p->Notify();  
79.   
80.     return 0;  
81.   
82. }  

[cpp]  view plain copy

1. #include <iostream>  
2. #include <vector>  
3. #include <string>  
4. using namespace std;  
5. class Secretary;  
6. // 看股票的同事类（观察对象，观察者）  
7. class StockObserver  
8. {  
9. public:  
10.     StockObserver(string strName, Secretary* strSub)  
11.     {  
12.         name = strName;  
13.         sub = strSub;  
14.     }  
15.   
16.     void Update();  
17.   
18. private:  
19.     string name;  
20.     Secretary* sub;  
21. };  
22.   
23. // 秘书类（主题对象，通知者）  
24. class Secretary  
25. {  
26.   
27. public:  
28.     string action;  
29.     void Add(StockObserver ob) { observers.push_back(ob); }  
30.     void Remove(int addIndex)  
31.     {  
32.         if(addIndex >=0 && addIndex < observers.size())  
33.         observers.erase(observers.begin() + addIndex);  
34.     }  
35.     void Notify()  
36.     {  
37.         vector<StockObserver>::iterator it;  
38.         for (it=observers.begin(); it!=observers.end(); ++it)  
39.         {  
40.             (*it).Update();  
41.         }  
42.     }  
43.   
44. private:  
45.     vector<StockObserver> observers;  
46. };  
47.   
48.   
49.   
50.   
51. void StockObserver::Update()  
52. {  
53.     cout << name << " : " << sub->action << ", begin to work" << endl;  
54. }  
55.   
56. int main()  
57. {  
58.     // 创建通知者  
59.     Secretary* p = new Secretary();  
60.   
61.     // 观察者  
62.     StockObserver* s1 = new StockObserver("Lazy", p);  
63.     StockObserver* s2 = new StockObserver("SnowFire", p);  
64.   
65.     // 加入通知队列  
66.     p->Add(*s1);  
67.     p->Add(*s2);  
68.   
69.     // 事件  
70.     p->action = "The boss is coming...";  
71.   
72.     // 通知  
73.     p->Notify();  
74.   
75.     // 动态删除  
76.     p->Remove(0);  
77.       
78.     p->Notify();  
79.   
80.     return 0;  
81.   
82. }  

适用性：

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

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

3．当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

优缺点：

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

    1．观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

    2．观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。

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

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

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

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

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