Observer 观察者

意图

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

动机

一致性,松耦合

需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合,因为这样降低了它们的可重用性。

比如:Excel中制作测试数据的折线图、饼状图和柱状图,以直观的表现出性能的变化。在实际操作时,我发现,如果我修改了一个数据,折线图、饼状图和柱状图就都发生了变换。

这一模式中的关键对象是目标(subject)和观察者(observer)。一个目标可以有任意数目的依赖它的观察者。一旦目标的状态发生改变 , 所有的观察者都得到通知。作为对这个通知的响应,每个观察者都将查询目标以使其状态与目标的状态同步。

这种交互也称为发布-订阅(publish-subscribe) 。目标是通知的发布者。它发出通知时并不需知道谁是它的观察者。可以有任意数目的观察者订阅并接收通知。

适用性

在以下任一情况下可以使用观察者模式 :

  • 当一个抽象模型有两个方面 , 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
  • 当对一个对象的改变需要同时改变其它对象 , 而不知道具体有多少对象有待改变。
  • 当一个对象必须通知其它对象,而它又不能假定其它对象是谁。换言之 , 你不希望这些对象是紧密耦合的。

结构

参与者

Subject

  • 目标知道它的观察者。可以有任意多个观察者观察同一个目标。
  • 提供注册和删除观察者对象的接口。

Observer

  • 为那些在目标发生改变时需获得通知的对象定义一个更新接口。

ConcreteSubject

  • 将有关状态存入各ConcreteObserver对象。
  • 当它的状态发生改变时, 向它的各个观察者发出通知。

ConcreteObserver

  • 维护一个指向ConcreteSubject对象的引用。
  • 存储有关状态,这些状态应与目标的状态保持一致。
  • 实现Observer的更新接口以使自身状态与目标的状态保持一致。

协作

  1. 当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时,它将通知它的各个观察者;
  2. 在得到一个具体目标的改变通知后,ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。

实现

  1 #include <iostream>
  2 #include <list>
  3 using namespace std;
  4
  5 class Observer
  6 {
  7 public:
  8      virtual void Update(int) = 0;
  9 };
 10
 11 class Subject
 12 {
 13 public:
 14      virtual void Attach(Observer *) = 0;
 15      virtual void Detach(Observer *) = 0;
 16      virtual void Notify() = 0;
 17 };
 18
 19 class ConcreteObserver : public Observer
 20 {
 21 public:
 22      ConcreteObserver(Subject *pSubject) : m_pSubject(pSubject){}
 23
 24      void Update(int value)
 25      {
 26           cout<<"ConcreteObserver get the update. New State:"<<value<<endl;
 27      }
 28
 29 private:
 30      Subject *m_pSubject;
 31 };
 32
 33 class ConcreteObserver2 : public Observer
 34 {
 35 public:
 36      ConcreteObserver2(Subject *pSubject) : m_pSubject(pSubject){}
 37
 38      void Update(int value)
 39      {
 40           cout<<"ConcreteObserver2 get the update. New State:"<<value<<endl;
 41      }
 42
 43 private:
 44      Subject *m_pSubject;
 45 };
 46
 47 class ConcreteSubject : public Subject
 48 {
 49 public:
 50      void Attach(Observer *pObserver);
 51      void Detach(Observer *pObserver);
 52      void Notify();
 53
 54      void SetState(int state)
 55      {
 56           m_iState = state;
 57      }
 58
 59 private:
 60      std::list<Observer *> m_ObserverList;
 61      int m_iState;
 62 };
 63
 64 void ConcreteSubject::Attach(Observer *pObserver)
 65 {
 66      m_ObserverList.push_back(pObserver);
 67 }
 68
 69 void ConcreteSubject::Detach(Observer *pObserver)
 70 {
 71      m_ObserverList.remove(pObserver);
 72 }
 73
 74 void ConcreteSubject::Notify()
 75 {
 76      std::list<Observer *>::iterator it = m_ObserverList.begin();
 77      while (it != m_ObserverList.end())
 78      {
 79           (*it)->Update(m_iState);
 80           ++it;
 81      }
 82 }
 83
 84 int main()
 85 {
 86      // Create Subject
 87      ConcreteSubject *pSubject = new ConcreteSubject();
 88
 89      // Create Observer
 90      Observer *pObserver = new ConcreteObserver(pSubject);
 91      Observer *pObserver2 = new ConcreteObserver2(pSubject);
 92
 93      // Change the state
 94      pSubject->SetState(2);
 95
 96      // Register the observer
 97      pSubject->Attach(pObserver);
 98      pSubject->Attach(pObserver2);
 99
100      pSubject->Notify();
101
102      // Unregister the observer
103      pSubject->Detach(pObserver);
104
105      pSubject->SetState(3);
106      pSubject->Notify();
107
108      delete pObserver;
109      delete pObserver2;
110      delete pSubject;
111 }
时间: 2024-10-02 21:15:46

Observer 观察者的相关文章

Java设计模式(五) Observer(观察者)模式及Tomcat引申

基本概念 Observer 观察者模式(Observer Pattern)又称为发布订阅模式(Publish/subscribe) 定义对象间的一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并且自动更新 根据单一职责原则,每个类的职责是单一的,我们可以通过触发机制,形成一个触发链,把各个单一的职责串联成真实世界中的复杂的逻辑关系. 观察者模式的角色分工(JDK中提供了抽象接口的定义): Subject被观察者: 抽象类型,定义被观察者必须实现的职责,动态地增加和

Design Pattern - Observer 观察者设计模式

Spy on enemy. 使用这个模式可以根据某些事件自动更新. 设计思路: 1 设计一个基类,作为需要观察一个时间行为的接口类 2 设计一个观察者类,可以观察所有基类的衍生类, 这里使用set来保存这些需要更新的类. 一个事件相当于一个函数,事件发生(调用函数)同时自动调用需要更新的函数动作. #pragma once #include <iostream> #include <string> #include <set> #include <vector&g

Observer(观察者)模式

在多个对象之间建立一对多的关系,以便当一个对象状态改变的时候,其他所有依赖于这个对象的对象都能得到通知,并被自动更新. 适用情况: 当一个抽象模型有两个方面,其中一个方面依赖于另一方面.将这二者封装在独立的对象中以使它们可以各自独立地改变和复用. 当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变. 当一个对象必须通知其它对象,而它又不能假定其它对象是谁. 调用setChanged()方法,触发继承自Observable类的Observers()方法将这次改变广播出去. no

设计模式之Observer(观察者)模式

需求: 有一个报社,用户可以随时订阅报纸,也可以随时取消订阅.当每天的新闻来的时候,报社用邮递员投递给订阅了报纸的用户.订阅者有老人.小孩和青年.   分析: 报社相当于被观察的对象,用户相当于观察者,一旦新闻有更新,报社就通知所有观察者.   类图:     扩展:  该类图使用的是"推"的方式将新闻推送给订阅者.还可以使用一种的"拉"的方式实现,在Update传递空参数,只是通知订阅者数据有更新,然后由订阅者自己去报社获取(GetNews).这种方式实现起来更麻

C#委托与事件之观察者Observer设计模式

前言    委托: 委托是一种在对象里保存方法引用的类型,同时也是一种类型安全的函数指针. 或委托可以看成一种表示函数的数据类型,类似函数指针. 事件是特殊的委托 观察者模式:两种角色:(1)Subject, 主题(被监视对象),它往往包含着 Observer 所感兴趣的内容.(2)Observer, 观察者,它观察 Subject. 当 Subject 中的某件事发生的时候(通常是它所感兴趣的内容改变的时候),会被自动告知,而 Observer 则会采取相应的行动(通常为更新自身状态或者显示输

设计模式 - 观察者模式(Observer Pattern) Java内置 使用方法

观察者模式(Observer Pattern) Java内置 使用方法 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26601659 观察者模式(observer pattern)详解, 参见: http://blog.csdn.net/caroline_wendy/article/details/26583157 Java内置的观察者模式, 是通过继承父类, 实现观察者模式的几个主要函数: Observerable(可被观

设计模式(行为型)之观察者模式(Observer Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(结构型)之代理模式(Proxy Pattern)>http://blog.csdn.net/yanbober/article/details/45480965 概述 观察者模式用于建立一种对象与对象之间的依赖关系,一个对象发生改变时将自动通知其他对象,其他对象将相应作

设计模式(19)--Observer(观察者模式)--行为型

作者QQ:1095737364    QQ群:123300273     欢迎加入! 1.模式定义: 观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式.模型-视图(Model/View)模式.源-监听器(Source/Listener)模式或从属者(Dependents)模式. 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己. 2.模式特点: 观察者模式

Observer模式详解--设计模式(15)

Observer模式来源: Observer模式应该可以说是应用最多.影响最广的模式之一. 因为Observer的一个实例Model/View/Control(MVC)结构在系统开发架构设计中有着很重要的地位和意义,MVC实现了业务逻辑和表示层的解耦.在MFC中,Doc/View(文档视图结构)提供了实现MVC的框架结构(有一个从设计模式(Observer模式)的角度分析分析Doc/View的文章正在进一步的撰写当中,遗憾的是时间:)).在Java阵容中,Struts则提供和MFC中Doc/Vi