当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。

介绍

意图

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

主要解决

一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。

何时使用

一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。例如某电子商务网站可以在执行发送操作后给用户多个发送商品打折信息,某团队战斗游戏中某队友牺牲将给所有成员提示等等,凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式。

如何解决

使用面向对象技术,可以将这种依赖关系弱化。

关键代码

在抽象类里有一个 List 存放观察者们。

应用实例

1、拍卖的时候,拍卖师观察最高标价,然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿,菩萨洒了一地水招来一个老乌龟,这个乌龟就是观察者,他观察菩萨洒水这个动作。

优点

  • 观察者模式可以实现表示层和数据逻辑层的分离,并定义了稳定的消息更新传递机制,抽象了更新接口,使得可以有各种各样不同的表示层作为具体观察者角色。
  • 观察者模式在观察目标和观察者之间建立一个抽象的耦合。
  • 观察者模式支持广播通信。
  • 观察者模式符合“开闭原则”的要求

    缺点

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

  • 如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
  • 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

    使用场景

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

  • 一个对象的改变将导致其他一个或多个对象也发生改变,而不知道具体有多少对象将发生改变,可以降低对象之间的耦合度。
  • 一个对象必须通知其他对象,而并不知道这些对象是谁。
  • 需要在系统中创建一个触发链,A对象的行为将影响B对象,B对象的行为将影响C对象……,可以使用观察者模式创建一种链式触发机制。

模式结构

观察者模式包含如下角色:

  • Subject: 目标
  • ConcreteSubject:具体目标
  • Observer:观察者
  • ConcreteObserver:具体观察者

观察者模式 - 图1

时序图

观察者模式 - 图2

代码实现

observerObject.cpp

  1. #include <iostream>
  2. #include "Subject.h"
  3. #include "Obeserver.h"
  4. #include "ConcreteObeserver.h"
  5. #include "ConcreteSubject.h"
  6. using namespace std;
  7. int main(int argc, char *argv[])
  8. {
  9. Subject * subject = new ConcreteSubject();
  10. Obeserver * objA = new ConcreteObeserver("A");
  11. Obeserver * objB = new ConcreteObeserver("B");
  12. subject->attach(objA);
  13. subject->attach(objB);
  14. subject->setState(1);
  15. subject->notify();
  16. cout << "--------------------" << endl;
  17. subject->detach(objB);
  18. subject->setState(2);
  19. subject->notify();
  20. delete subject;
  21. delete objA;
  22. delete objB;
  23. return 0;
  24. }

Subject.h

  1. #param once
  2. #include "Obeserver.h"
  3. #include <vector>
  4. using namespace std;
  5. class Subject
  6. {
  7. public:
  8. Subject();
  9. virtual ~Subject();
  10. Obeserver *m_Obeserver;
  11. void attach(Obeserver * pObeserver);
  12. void detach(Obeserver * pObeserver);
  13. void notify();
  14. virtual int getState() = 0;
  15. virtual void setState(int i)= 0;
  16. private:
  17. vector<Obeserver*> m_vtObj;
  18. };

Subject.cpp

  1. #include "Subject.h"
  2. Subject::Subject(){
  3. }
  4. Subject::~Subject(){
  5. }
  6. void Subject::attach(Obeserver * pObeserver){
  7. m_vtObj.push_back(pObeserver);
  8. }
  9. void Subject::detach(Obeserver * pObeserver){
  10. for(vector<Obeserver*>::iterator itr = m_vtObj.begin(); itr != m_vtObj.end(); itr++)
  11. {
  12. if(*itr == pObeserver)
  13. {
  14. m_vtObj.erase(itr);
  15. return;
  16. }
  17. }
  18. }
  19. void Subject::notify(){
  20. for(vector<Obeserver*>::iterator itr = m_vtObj.begin(); itr != m_vtObj.end(); itr++)
  21. {
  22. (*itr)->update(this);
  23. }
  24. }

Obeserver.h

  1. #param once
  2. class Subject;
  3. class Obeserver
  4. {
  5. public:
  6. Obeserver();
  7. virtual ~Obeserver();
  8. virtual void update(Subject * sub) = 0;
  9. };

ConcreteObeserver.h

  1. #param once
  2. #include "Obeserver.h"
  3. #include <string>
  4. using namespace std;
  5. class ConcreteObeserver : public Obeserver
  6. {
  7. public:
  8. ConcreteObeserver(string name);
  9. virtual ~ConcreteObeserver();
  10. virtual void update(Subject * sub);
  11. private:
  12. string m_objName;
  13. int m_obeserverState;
  14. };

ConcreteObeserver.cpp

  1. #include "ConcreteObeserver.h"
  2. #include <iostream>
  3. #include <vector>
  4. #include "Subject.h"
  5. using namespace std;
  6. ConcreteObeserver::ConcreteObeserver(string name){
  7. m_objName = name;
  8. }
  9. ConcreteObeserver::~ConcreteObeserver(){
  10. }
  11. void ConcreteObeserver::update(Subject * sub){
  12. m_obeserverState = sub->getState();
  13. cout << "update oberserver[" << m_objName << "] state:" << m_obeserverState << endl;
  14. }

Result:

  1. update observer[A] state: 1
  2. update observer[B] state: 1
  3. --------------------
  4. update observer[A] state: 2

模式分析

  • 观察者模式描述了如何建立对象与对象之间的依赖关系,如何构造满足这种需求的系统。
  • 这一模式中的关键对象是观察目标和观察者,一个目标可以有任意数目的与之相依赖的观察者,一旦目标的状态发生改变,所有的观察者都将得到通知。
  • 作为对这个通知的响应,每个观察者都将即时更新自己的状态,以与目标状态同步,这种交互也称为发布-订阅(publishsubscribe)。目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者,可以有任意数目的观察者订阅它并接收通

    模式扩展

    MVC模式

    MVC模式是一种架构模式,它包含三个角色:模型(Model),视图(View)和控制器(Controller)。观察者模式可以用来实现MVC模式,观察者模式中的观察目标就是MVC模式中的模型(Model),而观察者就是MVC中的视图(View),控制器(Controller)充当两者之间的中介者(Mediator)。当模型层的数据发生改变时,视图层将自动改变其显示内容。

    总结

  • 观察者模式定义对象间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅模式、模型-视图模式、源-监听器模式或从属者模式。观察者模式是一种对象行为型模式。

  • 观察者模式包含四个角色:目标又称为主题,它是指被观察的对象;具体目标是目标类的子类,通常它包含有经常发生改变的数据,当它的状态发生改变时,向它的各个观察者发出通知;观察者将对观察目标的改变做出反应;在具体观察者中维护一个指向具体目标对象的引用,它存储具体观察者的有关状态,这些状态需要和具体目标的状态保持一致。
  • 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个目标对象,当这个目标对象的状态发生变化时,会通知所有观察者对象,使它们能够自动更新。
  • 观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离,并在观察目标和观察者之间建立一个抽象的耦合,支持广播通信;其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间,而且如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
  • 观察者模式适用情况包括:一个抽象模型有两个方面,其中一个方面依赖于另一个方面;一个对象的改变将导致其他一个或多个对象也发生改变,而不知道具体有多少对象将发生改变;一个对象必须通知其他对象,而并不知道这些对象是谁;需要在系统中创建一个触发链。
  • 在JDK的java.util包中,提供了Observable类以及Observer接口,它们构成了Java语言对观察者模式的支持。

参考资料

https://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/observer.html
https://www.runoob.com/design-pattern/observer-pattern.html