观察者模式

　　观察者模式：在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。简单的来说就是发布者发布信息，观察者收到信息后，做出反应。

　　观察者模式定义了对象间一对多的依赖关系，主要解决的是对象状态改变给其他对象通知的问题，同时还要易用性和低耦合度。

实现：

　　观察者模式使用三个类Subject、Observer和Client。

1、创建Subject类。

 1 class Subject
 2 {
 3 private:
 4     vector<Observer*> observers;
 5     int state;
 6 
 7 public:
 8 
 9     void setState(int state)
10     {
11         //状态改变
12         this->state = state;
13         notifyAllObservers();
14     }
15 
16     void notifyAllObservers()
17     {
18         /*
19         vector<Observer*>::iterator ObsIter = observers.begin();
20         //观察者做出响应
21         for (; ObsIter!=observers.end(); ++ObsIter)
22         {
23             (*ObsIter)->update();
24         }
25         */
26         for (auto v : observers)
27         {
28             v->update();
29         }
30     }
31     //添加观察者
32     void addObserver(Observer* observer)
33     {
34         observers.push_back(observer);
35     }
36 };

 

2、创建Observer接口

class Observer
{
public:
    virtual void update() = 0;
    virtual ~Observer() {};
};

 

3、创建Observer实体观察者

 1 class AObserver : public Observer
 2 {
 3 public:
 4     virtual void update()
 5     {
 6         cout << "this is AObserver, Subject.state change" << endl;
 7     }
 8 };
 9 
10 class BObserver : public Observer
11 {
12 public:
13     virtual void update()
14     {
15         cout << "this is BObserver, Subject.state change" << endl;
16     }
17 };

 

4、使用Subject和Observer实体观察者

 

 1 class Client
 2 {
 3 public:
 4     Client()
 5     {
 6         subject->addObserver(aObserver);
 7         subject->addObserver(bObserver);
 8     }
 9     void changeSubjectState()
10     {
11         this->subject->setState(1);
12     }
13 private:
14     Subject* subject = new Subject();
15     Observer* aObserver = new AObserver();
16     Observer* bObserver = new BObserver();
17 };
18 
19 int main()
20 {
21     Client client;
22     client.changeSubjectState();
23 }

观察者模式优缺点：

　　优点：1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

　　缺点：1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

posted @ 2019-10-26 21:06  qetuo[  阅读(183)  评论(0)  编辑  收藏  举报