观察者模式在嵌入式系统中的应用与实践

编码文章call10242025-07-18 13:41:033A⁺A^-

观察者模式是嵌入式系统中实现数据实时分发的重要设计模式，其核心思想是当主题对象的数据发生变化时，主动通知所有订阅的观察者对象，从而实现松耦合的数据交互。在嵌入式场景中，该模式常用于传感器数据分发、事件广播等需要多组件实时响应的场景。

一、观察者模式的核心概念与结构

1. 模式定义与角色

观察者模式通过建立主题与观察者之间的一对多依赖关系，实现数据的自动分发，主要角色包括：

抽象主题 (Subject)：定义注册、删除观察者和通知观察者的接口。
具体主题 (ConcreteSubject)：实现主题接口，维护观察者列表，数据更新时通知观察者。
抽象观察者 (Observer)：定义接收通知的接口。
具体观察者 (ConcreteObserver)：实现观察者接口，处理接收到的数据。

2. 模式核心优势

松耦合：主题与观察者解耦，便于独立修改和扩展。
实时性：数据变化时主动通知，无需观察者轮询。
灵活性：可动态添加或移除观察者，适应系统需求变化。
资源优化：避免轮询带来的持续 CPU 占用。

二、观察者模式的程序实现示例

以下通过气体传感器数据分发的实例，展示观察者模式在 C 语言中的具体实现：

1. 接口定义与数据结构

// ObserverPattern.h - 观察者模式接口定义
#ifndef OBSERVER_PATTERN_H
#define OBSERVER_PATTERN_H

#include <stdint.h>

// 气体类型枚举
typedef enum {
    GAS_TYPE_02,
    GAS_TYPE_N2,
    GAS_TYPE_HE,
    GAS_TYPE_UNKNOWN
} GasType;

// 气体数据结构
typedef struct {
    GasType type;
    float concentration;
    uint32_t flowRate;
} GasData;

// 抽象观察者接口
typedef struct {
    void (*update)(struct GasObserver*, GasData);
} GasObserver;

// 抽象主题接口
typedef struct {
    void (*registerObserver)(struct GasSensor*, GasObserver*);
    void (*removeObserver)(struct GasSensor*, GasObserver*);
    void (*notifyObservers)(struct GasSensor*);
    void (*setGasData)(struct GasSensor*, GasData);
    GasData (*getGasData)(struct GasSensor*);
} GasSensor;
#endif // OBSERVER_PATTERN_H

2. 具体主题实现（气体传感器）

// GasSensor.c - 具体主题（气体传感器）实现
#include "ObserverPattern.h"
#include <stdio.h>
#include <stdlib.h>
// 最大观察者数量
#define MAX_OBSERVERS 10
// 气体传感器结构体
typedef struct {
GasSensor sensorIf;
GasData data;
GasObserver* observers[MAX_OBSERVERS];
 uint8_t observerCount;
} ConcreteGasSensor;
// 注册观察者
void ConcreteGasSensor_registerObserver(ConcreteGasSensor* me, GasObserver* observer) {
if (me->observerCount < MAX_OBSERVERS) {
 me->observers[me->observerCount++] = observer;
printf("Observer registered: %d\n", me->observerCount);
 }
}
// 移除观察者
void ConcreteGasSensor_removeObserver(ConcreteGasSensor* me, GasObserver* observer) {
for (uint8_t i = 0; i < me->observerCount; i++) {
if (me->observers[i] == observer) {
// 移除后将后面的观察者前移
for (uint8_t j = i; j < me->observerCount - 1; j++) {
 me->observers[j] = me->observers[j + 1];
 }
 me->observerCount--;
printf("Observer removed: %d\n", me->observerCount);
break;
 }
 }
}
// 通知所有观察者
void ConcreteGasSensor_notifyObservers(ConcreteGasSensor* me) {
for (uint8_t i = 0; i < me->observerCount; i++) {
 me->observers[i]->update(me->observers[i], me->data);
 }
}
// 设置气体数据并通知
void ConcreteGasSensor_setGasData(ConcreteGasSensor* me, GasData data) {
 me->data = data;
printf("New gas data: type=%d, conc=%.2f, flow=%d\n",
 data.type, data.concentration, data.flowRate);
ConcreteGasSensor_notifyObservers(me);
}
// 获取气体数据
GasData ConcreteGasSensor_getGasData(ConcreteGasSensor* me) {
return me->data;
}
// 创建气体传感器实例
ConcreteGasSensor* ConcreteGasSensor_create() {
ConcreteGasSensor* me = (ConcreteGasSensor*)malloc(sizeof(ConcreteGasSensor));
if (me) {
 me->sensorIf.registerObserver = (void (*)(struct GasSensor*, GasObserver*))ConcreteGasSensor_registerObserver;
 me->sensorIf.removeObserver = ConcreteGasSensor_removeObserver;
 me->sensorIf.notifyObservers = ConcreteGasSensor_notifyObservers;
 me->sensorIf.setGasData = ConcreteGasSensor_setGasData;
 me->sensorIf.getGasData = ConcreteGasSensor_getGasData;
 me->observerCount = 0;
// 初始化默认数据
 me->data.type = GAS_TYPE_UNKNOWN;
 me->data.concentration = 0.0f;
 me->data.flowRate = 0;
 }
return me;
}

3. 具体观察者实现（显示模块与控制模块）

// GasDisplay.c - 具体观察者（显示模块）实现
#include "ObserverPattern.h"
#include <stdio.h>
// 显示模块结构体
typedef struct {
GasObserver observerIf;
 uint8_t displayId;
} GasDisplay;
// 更新显示
void GasDisplay_update(GasObserver* iface, GasData data) {
GasDisplay* display = (GasDisplay*)iface;
 char* gasName;
switch (data.type) {
case GAS_TYPE_02: gasName = "Oxygen"; break;
case GAS_TYPE_N2: gasName = "Nitrogen"; break;
case GAS_TYPE_HE: gasName = "Helium"; break;
default: gasName = "Unknown"; break;
 }
printf("DISPLAY %d: %s - Conc: %.2f%%, Flow: %d cc/min\n",
 display->displayId, gasName, data.concentration, data.flowRate);
}
// 创建显示模块实例
GasDisplay* GasDisplay_create(uint8_t id) {
GasDisplay* me = (GasDisplay*)malloc(sizeof(GasDisplay));
if (me) {
 me->observerIf.update = GasDisplay_update;
 me->displayId = id;
 }
return me;
}
// GasController.c - 具体观察者（控制模块）实现
#include "ObserverPattern.h"
#include <stdio.h>
// 控制模块结构体
typedef struct {
GasObserver observerIf;
 uint8_t controllerId;
} GasController;
// 控制逻辑
void GasController_update(GasObserver* iface, GasData data) {
GasController* controller = (GasController*)iface;
printf("CONTROLLER %d: Processing gas data - Type: %d\n",
 controller->controllerId, data.type);
// 简单控制逻辑示例：氧气浓度低于20%时报警
if (data.type == GAS_TYPE_02 && data.concentration < 20.0f) {
printf("ALARM: Oxygen concentration low: %.2f%%\n", data.concentration);
 }
}
// 创建控制模块实例
GasController* GasController_create(uint8_t id) {
GasController* me = (GasController*)malloc(sizeof(GasController));
if (me) {
 me->observerIf.update = GasController_update;
 me->controllerId = id;
 }
return me;
}

4. 客户端使用示例

// 客户端代码示例
#include "ObserverPattern.h"
int main() {
// 创建气体传感器
ConcreteGasSensor* gasSensor = ConcreteGasSensor_create();
if (!gasSensor) {
printf("Failed to create gas sensor\n");
return 1;
 }
// 创建观察者
GasDisplay* display1 = GasDisplay_create(1);
GasDisplay* display2 = GasDisplay_create(2);
GasController* controller1 = GasController_create(1);
// 注册观察者
 gasSensor->sensorIf.registerObserver((struct GasSensor*)gasSensor, (GasObserver*)display1);
 gasSensor->sensorIf.registerObserver((struct GasSensor*)gasSensor, (GasObserver*)display2);
 gasSensor->sensorIf.registerObserver((struct GasSensor*)gasSensor, (GasObserver*)controller1);
// 模拟传感器数据更新
GasData data1 = {.type = GAS_TYPE_02, .concentration = 21.0f, .flowRate = 100};
 gasSensor->sensorIf.setGasData((struct GasSensor*)gasSensor, data1);
// 模拟另一个气体数据更新
GasData data2 = {.type = GAS_TYPE_N2, .concentration = 78.0f, .flowRate = 500};
 gasSensor->sensorIf.setGasData((struct GasSensor*)gasSensor, data2);
// 移除一个观察者
 gasSensor->sensorIf.removeObserver((struct GasSensor*)gasSensor, (GasObserver*)display2);
printf("\nAfter removing display2:\n");
// 模拟氧气浓度低的情况
GasData data3 = {.type = GAS_TYPE_02, .concentration = 18.5f, .flowRate = 80};
 gasSensor->sensorIf.setGasData((struct GasSensor*)gasSensor, data3);
// 释放资源
free(display1);
free(display2);
free(controller1);
free(gasSensor);
return 0;
}

三、观察者模式流程图示意

┌───────────────────────┐            ┌───────────────────────┐
│ 客户端(Client)                                │────│ 具体主题(ConcreteSubject)            │
│ 创建传感器与观察者                       │             │ 气体传感器                                     │
└───────────────────────┘            └───────────────────────┘
                                                         ▲             │
                                                         │             │
                                                         ▼            │
┌───────────────────────┐            ┌───────────────────────┐
│ 注册观察者                                     │────│ 维护观察者列表                              │
└───────────────────────┘            └───────────────────────┘
                                                          │            │
                                                          ▼           │
┌───────────────────────┐             ┌───────────────────────┐
│ 设置新气体数据                               │────│ 通知所有观察者                              │
└───────────────────────┘             └───────────────────────┘
                                                          │            │
                                                         ▼            │
┌───────────────────────┐            ┌───────────────────────┐
│ 遍历观察者列表                              │────│ 调用观察者update方法                   │
└───────────────────────┘            └───────────────────────┘
                                                         │             │
                                                         ▼            │
┌───────────────────────┐             ┌───────────────────────┐
│ 具体观察者处理数据                        │────│ 显示模块/控制模块                          │
└───────────────────────┘             └───────────────────────┘

流程说明：

初始化阶段：客户端创建气体传感器主题和显示 / 控制观察者。
注册阶段：观察者向主题注册，主题维护观察者列表。
数据更新：传感器数据变化时，主题调用setGasData方法。
通知分发：主题遍历观察者列表，调用每个观察者的update方法。
处理响应：观察者接收到数据后，执行各自的处理逻辑（如显示数据、触发报警）。
动态调整：可随时添加或移除观察者，适应系统需求变化。

四、观察者模式的应用场景与优化策略

1. 典型应用场景

传感器网络：环境监测系统中多传感器数据实时分发。
医疗设备：生命体征监测数据同步显示与分析。
工业控制：设备状态变化时通知多个监控模块。
车载系统：传感器数据更新时同步显示仪表盘和控制系统。

2. 性能优化策略

批量通知：积累多个数据变化后批量通知，减少通知频率。
优先级队列：为观察者设置优先级，紧急通知优先处理。
数据过滤：主题可过滤无效数据，避免无意义通知。
异步通知：使用队列缓冲通知，避免阻塞主题线程。

3. 与其他模式的结合

与工厂模式结合：动态创建不同类型的观察者，适配不同显示设备。
与中介者模式结合：通过中介者协调主题与观察者的交互，简化复杂逻辑。
与策略模式结合：为不同观察者提供不同的数据处理策略。

五、观察者模式的实践价值与注意事项

1. 核心价值

实时响应：数据变化时立即通知，无需轮询，提升系统实时性。
可扩展性：新增观察者时无需修改主题代码，符合开闭原则。
代码复用：主题与观察者可独立复用，提高开发效率。
维护性：松耦合结构便于理解和维护系统架构。

2. 实施注意事项

内存管理：注意观察者的注册与注销，避免内存泄漏。
通知顺序：考虑通知顺序对观察者处理逻辑的影响。
数据一致性：确保观察者接收到的数据一致，避免并发问题。
性能瓶颈：大量观察者时，注意通知性能，可采用异步或批量处理。

观察者模式在嵌入式系统中为多组件协同工作提供了高效的数据分发机制，通过将数据发布与订阅解耦，使系统更具灵活性、可扩展性和维护性。在实际项目中，合理应用该模式可显著提升复杂嵌入式系统的设计质量与开发效率。

点击这里复制本文地址以上内容由文彬编程网整理呈现，请务必在转载分享时注明本文地址！如对内容有疑问，请联系我们，谢谢！

uint32_t最大值

上一篇：IOS逆向--恢复Dyld的内存加载方式

下一篇：【建议收藏】一文入门CAN协议（can协议规范）

观察者模式在嵌入式系统中的应用与实践

相关文章