设计模式之「观察者」模式

简介: 设计模式之「观察者」模式

1.观察者(Observer)模式动机


在软件构建过程中,我们需要为某些对象建立一种“通知依赖关系”:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密,将会使软件不能很好地抵御变化。使用面向对象技术,可以将这种依赖关系弱化,并形成一种稳定的依赖关系,从而实现软件体系结构松耦合。


2.观察者(Observer)模式定义


定义对象间的一种一对多(变化)的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动更新举个例子来说,我每次更新了公众号文章后,作为公众号的关注者,然后你会在第一时间收到推送信息。如果你觉得文章质量不错,也许会给作者来个一键三连。换句话,每当更新公众号文章这个动作发生后,可能会引起关注者一键三连行为。因此,作者更新公众号文章这个动作并不是孤立存在的,而是与多个对象产生依赖关系的。


3.观察者(Observer)模式UML图


69.png

(1).Subject(抽象被观察者):定义了一个观察者的集合,即一个被观察者可能会有多个观察者,通过attach()和detach()方法来增删观察者。被观察者中声明通知方法notify(),该方法用于当被观察者状态发生改变时通知观察者。(2).ConcreteSubject(具体被观察者)实现通知方法notify(),同时具体被观察者具有记录自身状态的属性和成员方法。
(3).Observer(抽象观察者)接收到被观察者状态发生改变的通知并做出反应,抽象被观察者中声明更新方法update()。
(4).ConcreteObserver(具体观察者)实现更新方法update(),具体观察者中维护了一个具体被观察者对象的引用,用于存储抽象被观察者的状态。


68.jpg


4.观察者(Observer)模式实战


下面以“吃鸡”这个游戏来举例说明观察者模式的应用,该游戏中当其中一个队友发现物资时,可以发出“我这里有物资”的消息。此时,其他队友收到后就会过去获取物资;当其中一个队友被敌人击倒后,可以发出“快救我”。此时,其他队友收到后就会赶过去救队友。

67.jpg

抽象观察者Observer声明发现物资和发出求救时的呼叫方法call()具体观察者是吃鸡玩家Player,具体观察者中实现了call()方法。此外,Player中还定义了获取物资get()和救助队友help()两个方法。联盟中心AllyCenter是抽象被观察者,它维护了玩家列表PlayerList,并定义加入战队和踢出玩家方法。具体被观察者是联盟中心控制器AllyCenterController,它实现了notify()方法,此方法用于将吃鸡玩家call()方法中传递的消息发送给玩家列表的其他队友,并做出响应。


/* common.h */
#ifndef __COMMON_H__
#define __COMMON_H__
enum INFO_TYPE{
 NONE,
 RESOURCE,
 HELP
};
#endif
/* AllyCenter.h */
#ifndef __ALLYCENTER_H__
#define __ALLYCENTER_H__
#include "common.h"
#include <vector>
// 前向声明
class Observer;
class Player;
// 抽象目标:联盟中心
class AllyCenter
{
public:
 AllyCenter();
 // 声明通知方法
 virtual void notify(INFO_TYPE infoType, std::string name) = 0;
 // 加入玩家
 void join(Observer* player);
 // 踢出玩家
 void remove(Observer* player);
protected:
 // 玩家列表
 std::vector<Observer*>playerList;
};
// 具体目标
class AllyCenterController :public AllyCenter
{
public:
 AllyCenterController();
 // 实现通知方法
 void notify(INFO_TYPE infoType, std::string name);
};
#endif
/* Observer.h */
#ifndef __OBSERVER_H__
#define __OBSERVER_H__
#include <iostream>
using namespace std;
#include "common.h"
#include "AllyCenter.h"
// 抽象观察者 Observer
class Observer
{
public:
 Observer(){}
 // 声明抽象方法
 virtual void call(INFO_TYPE infoType, AllyCenter* ac) = 0;
 string getName(){
  return name;
 }
 void setName(string iName){
  this->name = iName;
 }
private:
 string name;
};
// 具体观察者 
class Player :public Observer
{
public:
 Player(){
  setName("none");
 }
 Player(string iName){
  setName(iName);
 }
 // call()具体实现
 void call(INFO_TYPE infoType, AllyCenter* ac){
  switch (infoType){
  case RESOURCE:
   printf("%s: 发现物资,快来~\n", getName().c_str());
   break;
  case HELP:
   printf("%s: 救救我~\n", getName().c_str());
   break;
  default:
   printf("Everything is ok!\n");
  }
  ac->notify(infoType, getName());
 }
 // 救助队友方法help()
 void help(){
  printf("%s: 坚持住,马上赶来救你!\n", getName().c_str());
 }
 // 获取物资方法get()
 void get(){
  printf("%s: 已收到,马上过来分享物资!\n", getName().c_str());
 }
};
#endif
/* AllyCenter.cpp */
#include "AllyCenter.h"
#include "Observer.h"
AllyCenter::AllyCenter(){
 printf("大吉大利,今晚吃鸡!\n");
}
// 加入玩家
void AllyCenter::join(Observer* player){
 if (playerList.size() == 4){
  printf("吃鸡玩家已满!\n");
  return;
 }
 printf("玩家 %s 正在加入中......\n", player->getName().c_str());
 playerList.push_back(player);
 if (playerList.size() == 4){
  printf("组队成功,马上开局!\n");
 }
}
// 剔除玩家
void AllyCenter::remove(Observer* player){
 printf("玩家%s退出房间\n", player->getName().c_str());
}
AllyCenterController::AllyCenterController(){
}
// 实现通知方法
void AllyCenterController::notify(INFO_TYPE infoType, std::string name){
 switch (infoType){
 case RESOURCE:
  for (Observer* obj : playerList){
   if (obj->getName() != name){
    ((Player*)obj)->get();
   }
  }
  break;
 case HELP:
  for (Observer* obj : playerList){
   if (obj->getName() != name){
    ((Player*)obj)->help();
   }
  }
  break;
 default:
  printf("Everything is ok!\n");
 }
}
/* main.cpp*/
#include "Observer.h"
#include "AllyCenter.h"
// 客户端程序
int main()
{
 // 创建一个战队
 AllyCenterController* controller = new AllyCenterController();
 // 创建4个吃鸡玩家,并加入战队
 Player* CurryCoder = new Player("CurryCoder");
 Player* Durant = new Player("Durant");
 Player* Harden = new Player("Harden");
 Player* James = new Player("James");
 controller->join(CurryCoder);
 controller->join(Durant);
 controller->join(Harden);
 controller->join(James);
 printf("\n\n");
 // CurryCoder发现物资,呼叫队友
 CurryCoder->call(RESOURCE, controller);
 printf("\n\n");
 // Durant需要求救
 Durant->call(HELP, controller);
 printf("\n\n");
 return 0;
}


66.png


5.观察者(Observer)模式总结


(1).使用面向对象的抽象,观察者(Observer)模式使得我们可以独立地改变目标与观察者,从而使两者之间的依赖关系达到松耦合。

(2).目标发送通知时,无需指定观察者,通知(可以携带通知信息作为参数)会自动传播。

(3).观察者自己决定是否需要订阅通知,目标对象对此一无所知;

(4).观察者(Observer)模式是基于事件的UI框架中十分常用的设计模式,也是MVC模式的一个重要组成部分。

相关文章
|
5天前
|
设计模式 算法 安全
设计模式——模板模式
模板方法模式、钩子方法、Spring源码AbstractApplicationContext类用到的模板方法
设计模式——模板模式
|
1月前
|
设计模式
设计模式-单一职责模式
设计模式-单一职责模式
|
1月前
|
设计模式 XML 存储
【二】设计模式~~~创建型模式~~~工厂方法模式(Java)
文章详细介绍了工厂方法模式(Factory Method Pattern),这是一种创建型设计模式,用于将对象的创建过程委托给多个工厂子类中的某一个,以实现对象创建的封装和扩展性。文章通过日志记录器的实例,展示了工厂方法模式的结构、角色、时序图、代码实现、优点、缺点以及适用环境,并探讨了如何通过配置文件和Java反射机制实现工厂的动态创建。
【二】设计模式~~~创建型模式~~~工厂方法模式(Java)
|
1月前
|
设计模式 XML Java
【一】设计模式~~~创建型模式~~~简单工厂模式(Java)
文章详细介绍了简单工厂模式(Simple Factory Pattern),这是一种创建型设计模式,用于根据输入参数的不同返回不同类的实例,而客户端不需要知道具体类名。文章通过图表类的实例,展示了简单工厂模式的结构、时序图、代码实现、优缺点以及适用环境,并提供了Java代码示例和扩展应用,如通过配置文件读取参数来实现对象的创建。
【一】设计模式~~~创建型模式~~~简单工厂模式(Java)
|
1月前
|
设计模式 uml C语言
设计模式----------工厂模式之简单工厂模式(创建型)
这篇文章详细介绍了简单工厂模式,包括其定义、应用场景、UML类图、通用代码实现、运行结果、实际应用例子,以及如何通过反射机制实现对象创建,从而提高代码的扩展性和维护性。
设计模式----------工厂模式之简单工厂模式(创建型)
|
1月前
|
设计模式 uml
设计模式-------------工厂模式之工厂方法模式(创建型)
工厂方法模式是一种创建型设计模式,它通过定义一个用于创建对象的接口,让子类决定实例化哪一个类,从而实现类的实例化推迟到子类中进行,提高了系统的灵活性和可扩展性。
|
1月前
|
设计模式 测试技术 Go
[设计模式]创建型模式-简单工厂模式
[设计模式]创建型模式-简单工厂模式
|
2月前
|
设计模式 算法 Java
跟着GPT学设计模式之模板模式
模板模式是一种行为型设计模式,它定义了一个操作中的算法骨架,将一些步骤的具体实现延迟到子类中。该模式使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤。
44 6
|
1月前
|
设计模式 人工智能 达摩院
设计模式的基础问题之模板模式在软件开发中的优势是什么
设计模式的基础问题之模板模式在软件开发中的优势是什么
|
1月前
|
设计模式 项目管理
设计模式的基础问题之生成器模式在项目管理应用的问题如何解决
设计模式的基础问题之生成器模式在项目管理应用的问题如何解决