当前位置:首页 > 公众号精选 > 裸机思维

说在前面

在现代嵌入式软件结构中,解耦设计逐渐成为提升系统灵活性和可维护性的关键,而观察者模式正是一种有效实现这种设计理念的手段。这一次,我将从C语言的角度出发,基于上一章的面向对象,详细探讨如何构建一个高效且灵活的观察者系统,并通过实际案例展示这种模式在事件通知和状态更新中的应用。

举个?

我们从一个案例开始,假设我们在开发一个家用温湿度传感器。这个产品可以接受实时温湿度。程序会将温湿度的数值显示在段码屏上。同时,这部分数据也会通过BLE发送到手机APP上。每当温度发生变化时,显示器及APP上,都会同时被更新。



最简单直接的思路

首先,我们创建一个 display 类,用于模拟显示温湿度

#include 
typedef struct _display_t {    // 省略和底层相关的属性} display_t;
// 静态构造函数void display_init(display_t *display) {    // 省略对底层相关属性初始化}
// 模拟屏幕显示void display_show(display_t *display, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}

接下来, 我们创建一个 ble 类,用于模拟蓝牙传输温湿度

#include 
typedef struct _ble_t {    // 省略和底层相关的属性} ble_t;
// 静态构造函数void ble_init(ble_t* ble) {    // 省略对底层相关属性初始化}
// 模拟蓝牙发送void ble_send(ble_t* ble, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}

再创建一个温湿度传感器类,模拟获取温湿度


typedef struct _sensor_t{    int temp;    int hum;    // 省略和底层相关的属性    display_t *disp;    ble_t *ble;} sensor_t;
// 静态构造函数void sensor_init(sensor_t* sensor, display_t *disp, ble_t *ble){    sensor->temp = 0;    sensor->hum = 0;    sensor->disp = disp;    sensor->ble = ble;}
// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    display_show(sensor->disp, temp, hum);    ble_send(sensor->ble, temp, hum);}

写一个调用的main。


int main() {    // 初始化显示模块    display_t my_display;    display_init(&my_display);        // 初始化蓝牙模块    ble_t my_ble;    ble_init(&my_ble);        // 初始化温湿度传感器    sensor_t sensor;    sensor_init(&sensor, &my_display, &my_ble);        // 模拟读取温湿度数据(25°C,50%湿度)    sensor_get(&sensor, 25, 50);        return 0;}

运行结果:

temp:25hum:50send temp:25send hum:50

虽然我们用最简单的方式完成了需求。但是,上述做法有个最大的问题。就是温湿度传感器对象内部需要依赖display和ble对象。这导致两个耦合问题:

  • 当display和ble对象属性或者方法修改时,对应的温湿度传感器对象也要修改。

  • 当有新的显示媒介对象接入后,温湿度传感器要修改。

总之,这种方式会导致对象之间的相互依赖,数据很难解耦。

基于观察者模式的思路

首先,还是原封不动封装  display 类和  ble 类。这两种类,都被称之为“观察者”。我们为“观察者们”建立一个统一的父类 Observer:

typedef struct _observer_t{     void (*update)(struct _observer_t*, int, int);} observer_t ;
void observer_init(observer_t *obs){    obs->update = NULL;}
void observer_update(observer_t *obs, int temp, int hum){    if (obs->update != NULL)    {        obs->update(obs, temp, hum);    }}

这个接口将所有的观察者在观测时发生的不同动作进行统一包装。

接下来,我们让display类继承它:

#include 
typedef struct _display_t {    observer_t obs;} display_t;
void display_show(observer_t *obs, int temp, int hum);
// 静态构造函数void display_init(display_t *display) {    observer_init(&display->obs);    display->obs.update = display_show;}
// 模拟屏幕显示void display_show(observer_t *obs, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}

这样,当数据发生变化的时候。我们无需关注子类如何实现,直接关注它的父类的update方法即可。
我们同样让ble类继承observer类:

#include 
typedef struct _ble_t {    observer_t obs;} ble_t;
void ble_send(observer_t *obs, int temp, int hum);
// 静态构造函数void ble_init(ble_t* ble) {    observer_init(&ble->obs);    ble->obs.update = ble_send;}
// 模拟蓝牙发送void ble_send(observer_t *obs, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}

接下来,我们来看温湿度传感器类。该类属于被观察的对象,需要完成attach,detach和notify。其中,attach和detach是用于收集观察者。而notify则是遍历收集到的观察者,并统一调用update。

typedef struct _sensor_t {    int temp;    int hum;    observer_t *obs;} sensor_t;
// 静态构造函数void sensor_init(sensor_t *sensor){    sensor->temp = 0;    sensor->hum = 0;    sensor->obs = NULL;}
// 添加观察者void sensor_attach(sensor_t *sensor, observer_t *obs){    if (!sensor->obs) {        sensor->obs = obs;    } else {        observer_t *cur = sensor->obs;        while (cur->next) cur = cur->next;        cur->next = obs;    }}
// 删除观察者void sensor_detach(sensor_t *sensor, observer_t *obs){    observer_t **indirect = &sensor->obs; // 使用二级指针简化操作    while (*indirect) {        if (*indirect == obs) {            *indirect = obs->next; // 绕过目标节点            obs->next = NULL;      // 重置观察者的next指针            return;        }        indirect = &(*indirect)->next;    }}
// 通知观察者void sensor_notify(sensor_t *sensor, int temp, int hum){    observer_t *_obs = sensor->obs;    while(_obs)    {        observer_update(_obs, temp, hum);        _obs = _obs->next;    }}
// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    sensor_notify(sensor, temp, hum);}

根据需求,我们要简单修改一下观察者类:

typedef struct _observer_t{     void (*update)(struct _observer_t*, int, int);    struct _observer_t *next;} observer_t ;
void observer_init(observer_t *obs){    obs->update = NULL;    obs->next= NULL;}
void observer_update(observer_t *obs, int temp, int hum){    if (obs->update != NULL)    {        obs->update(obs, temp, hum);    }}

最后,让我们写一个例子看看:

int main() {    // 创建传感器和观察者实例    sensor_t sensor;    sensor_init(&sensor);    display_t display;    display_init(&display);    ble_t ble;    ble_init(&ble);

    // 注册观察者(显示和蓝牙)    sensor_attach(&sensor, (observer_t*)&display);    sensor_attach(&sensor, (observer_t*)&ble);
    // 模拟第一次数据读取(会触发两个观察者)    printf("=== First measurement ===\n");    sensor_get(&sensor, 25, 60);
    // 移除蓝牙观察者    sensor_detach(&sensor, (observer_t*)&ble);
    // 模拟第二次数据读取(只会触发显示)    printf("\n=== Second measurement ===\n");    sensor_get(&sensor, 26, 58);
    return 0;}

运行结果:

== First measurement ===temp:25hum:60send temp:25send hum:60
=== Second measurement ===temp:26hum:58

如果上述“干巴巴”的代码不好理解,我总结了下面这幅UML图帮助理解:

通过观察者这个父类。传感器类的依赖变成了稳定的观察者类而不是子类。如果修改子类的方法,与传感器类无关。如果增加一个新的传感器,只需要继承观察者类,并重写update即可。对其它类无任何影响。

多主题多观察者模型

在上述的模型中,我们只考虑了传感器是一种。那么当传感器有多种的时候,虽然不同传感器对象不同。但是共同都有notify,detach和attach三种方法。这种情况我们就想到了,能否将这部分的内容封装成父类subject:

typedef struct _subject_t{    observer_t *obs;} subject_t;
// 静态初始化主题对象void subject_init(subject_t *subject){    subject->obs = NULL;}
// 收集观察者void subject_attach(subject_t *subject, observer_t *obs){    if (!subject->obs) {        subject->obs = obs;    } else {        observer_t *cur = subject->obs;        while (cur->next) cur = cur->next;        cur->next = obs;    }}
// 删除观察者void subject_detach(subject_t *subject, observer_t *obs){    observer_t **indirect = &subject->obs; // 使用二级指针简化操作    while (*indirect) {        if (*indirect == obs) {            *indirect = obs->next; // 绕过目标节点            obs->next = NULL;      // 重置观察者的next指针            return;        }        indirect = &(*indirect)->next;    }}
// 数据通知订阅者void subject_notify(subject_t *subject, int temp, int hum){    observer_t *_obs = subject->obs;    while(_obs)    {        observer_update(_obs, temp, hum);        _obs = _obs->next;    }}

而温湿度传感器对象则继承subject:

typedef struct _sensor_t {    subject_t subject;    int temp;    int hum;} sensor_t;
// 静态构造函数void sensor_init(sensor_t *sensor){    sensor->temp = 0;    sensor->hum = 0;    subject_init(&sensor->subject);}// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    subject_notify((subject_t *)sensor, temp, hum);}

接下来我们来优化其调用,之前的调用是需要手动调用attach和detach方法。我们可以通过让观察者初始化时指定主题对象,来达到减少调用的目的。

typedef struct _observer_t{     void (*update)(struct _observer_t*, int, int);    struct _observer_t *next;    subject_t *subject;} observer_t ;
void observer_init(observer_t *obs, subject_t *subject){    obs->update = NULL;    obs->next= NULL;    obs->subject = subject;    subject_attach(subject, obs);}
void observer_deinit(observer_t *obs, subject_t *subject){    subject_detach(obs->subject, obs);}
void observer_update(observer_t *obs, int temp, int hum){    if (obs->update != NULL)    {        obs->update(obs, temp, hum);    }}

对应的display和ble的构造函数也得修改

#include 
typedef struct _display_t {    observer_t obs;} display_t;
void display_show(observer_t *obs, int temp, int hum);
// 静态构造函数void display_init(display_t *display, subject_t *subject) {    observer_init(&display->obs, subject);    display->obs.update = display_show;}
// 模拟屏幕显示void display_show(observer_t *obs, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}
typedef struct _ble_t {    observer_t obs;} ble_t;
void ble_send(observer_t *obs, int temp, int hum);
// 静态构造函数void ble_init(ble_t* ble, subject_t *subject) {    observer_init(&ble->obs, subject);    display->obs.update = ble_send;}
// 模拟蓝牙发送void ble_send(observer_t *obs, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}

最后,我们添加main。对上述代码进行调用:

int main() {    // 创建传感器实例    sensor_t my_sensor;    sensor_init(&my_sensor);
    // 创建显示设备和蓝牙设备    display_t screen;    display_init(&screen, (subject_t*)&my_sensor);    ble_t ble_device;    ble_init(&ble_device, (subject_t*)&my_sensor);
    // 第一次数据更新(两个设备都应响应)    printf("=== First Update ===\n");    sensor_get(&my_sensor, 25, 60);
    // 移除蓝牙设备(通过反初始化)    printf("\n=== Detaching BLE ===\n");    observer_deinit(&ble_device.obs);
    // 第二次数据更新(仅显示设备响应)    printf("\n=== Second Update ===\n");    sensor_get(&my_sensor, 26, 58);
    return 0;}

运行结果:

=== First Update ===temp:25hum:60send temp:25send hum:60
=== Detaching BLE ===
=== Second Update ===temp:26hum:58

这种方式, 如果有多个对象继承subject,然后在对应的函数里调用notify就行了。此外,这次修改可以在观察者初始化的时候订阅主题对象。这样就不必麻烦的调用attach和detach方法了,让调用变得更加简单。

发布订阅模式和观察者模式的区别

发布订阅模式和消息订阅模式是一样的吗?

消息订阅模式,是一种各个系统组件的通信方式。在这种模式下,发布者可以是系统中不同类型的消息服务或者事件服务。而订阅者可以是具体的网关服务,路由服务等。发布者和订阅者互相都不知道对方的存在,通过消息代理部分进行分发。订阅者会告诉消息代理自己感兴趣的消息类型,当发布者进行发布对应的消息时,订阅者就会将该消息转发给订阅者进行处理。这就是发布订阅的基本形式。

观察者模式发布订阅模式
一种面向对象的软件设计模式,代码组成的一种解耦思想,一种消息分发的组件,指定消息传递的方式

以下提供完整可运行代码,供学习理解

最简单直接的思路——完整代码

#include 
typedef struct _display_t {    // 省略和底层相关的属性} display_t;
// 静态构造函数void display_init(display_t *display) {    // 省略对底层相关属性初始化}
// 模拟屏幕显示void display_show(display_t *display, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}
typedef struct _ble_t {    // 省略和底层相关的属性} ble_t;
// 静态构造函数void ble_init(ble_t* ble) {    // 省略对底层相关属性初始化}
// 模拟蓝牙发送void ble_send(ble_t* ble, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}
typedef struct _sensor_t{    int temp;    int hum;    // 省略和底层相关的属性    display_t *disp;    ble_t *ble;} sensor_t;
// 静态构造函数void sensor_init(sensor_t* sensor, display_t *disp, ble_t *ble){    sensor->temp = 0;    sensor->hum = 0;    sensor->disp = disp;    sensor->ble = ble;}
// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    display_show(sensor->disp, temp, hum);    ble_send(sensor->ble, temp, hum);}

int main() {    // 初始化显示模块    display_t my_display;    display_init(&my_display);        // 初始化蓝牙模块    ble_t my_ble;    ble_init(&my_ble);        // 初始化温湿度传感器    sensor_t sensor;    sensor_init(&sensor, &my_display, &my_ble);        // 模拟读取温湿度数据(25°C,50%湿度)    sensor_get(&sensor, 25, 50);        return 0;}

基于观察者模式的思路——完整代码

#include 
typedef struct _observer_t{    void (*update)(struct _observer_t*, int, int);    struct _observer_t *next;} observer_t;
void observer_init(observer_t *obs){    obs->update = NULL;    obs->next= NULL;}
void observer_update(observer_t *obs, int temp, int hum){    if (obs->update != NULL)    {        obs->update(obs, temp, hum);    }}
typedef struct _display_t{    observer_t obs;} display_t;
void display_show(observer_t *obs, int temp, int hum);
// 静态构造函数void display_init(display_t *display) {    observer_init(&display->obs);    display->obs.update = display_show;}
// 模拟屏幕显示void display_show(observer_t *obs, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}

typedef struct _ble_t {    observer_t obs;} ble_t;
void ble_send(observer_t *obs, int temp, int hum);
// 静态构造函数void ble_init(ble_t* ble) {    observer_init(&ble->obs);    ble->obs.update = ble_send;}
// 模拟蓝牙发送void ble_send(observer_t *obs, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}
typedef struct _sensor_t {    int temp;    int hum;    observer_t *obs;} sensor_t;
// 静态构造函数void sensor_init(sensor_t *sensor){    sensor->temp = 0;    sensor->hum = 0;    sensor->obs = NULL;}
// 添加观察者void sensor_attach(sensor_t *sensor, observer_t *obs){    if (!sensor->obs) {        sensor->obs = obs;    } else {        observer_t *cur = sensor->obs;        while (cur->next) cur = cur->next;        cur->next = obs;    }}
// 删除观察者void sensor_detach(sensor_t *sensor, observer_t *obs){    observer_t **indirect = &sensor->obs; // 使用二级指针简化操作    while (*indirect) {        if (*indirect == obs) {            *indirect = obs->next; // 绕过目标节点            obs->next = NULL;      // 重置观察者的next指针            return;        }        indirect = &(*indirect)->next;    }}
// 通知观察者void sensor_notify(sensor_t *sensor, int temp, int hum){    observer_t *_obs = sensor->obs;    while(_obs)    {        _obs->update(_obs, temp, hum);        _obs = _obs->next;    }}
// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    sensor_notify(sensor, temp, hum);}
int main() {    // 创建传感器和观察者实例    sensor_t sensor;    sensor_init(&sensor);    display_t screen;    display_init(&screen);    ble_t ble_device;    ble_init(&ble_device);

    // 注册观察者(显示和蓝牙)    sensor_attach(&sensor, (observer_t*)&screen);    sensor_attach(&sensor, (observer_t*)&ble_device);
    // 模拟第一次数据读取(会触发两个观察者)    printf("=== First measurement ===\n");    sensor_get(&sensor, 25, 60);
    // 移除蓝牙观察者    sensor_detach(&sensor, (observer_t*)&ble_device);
    // 模拟第二次数据读取(只会触发显示)    printf("\n=== Second measurement ===\n");    sensor_get(&sensor, 26, 58);
    return 0;}

多主题多观察者模型——完整代码

#include 
// 前置声明typedef struct _subject_t subject_t;typedef struct _observer_t observer_t;
void subject_attach(subject_t *sub, observer_t *obs);void subject_detach(subject_t *sub, observer_t *obs);
typedef struct _observer_t{    void (*update)(struct _observer_t*, int, int);  // 修正函数指针语法    struct _observer_t *next;    struct _subject_t *subject;    // 添加前向声明} observer_t;

void observer_init(observer_t *obs, subject_t *subject){    obs->update = NULL;    obs->next = NULL;    obs->subject= subject;    subject_attach(subject, obs);}
void observer_deinit(observer_t *obs)  // 移除多余参数{    subject_detach(obs->subject, obs);}
void observer_update(observer_t *obs, int temp, int hum){    if (obs->update != NULL)    {        obs->update(obs, temp, hum);    }}
// subject_t 结构定义示例struct _subject_t {    observer_t *obs;};
// 静态初始化主题对象void subject_init(subject_t *subject){    subject->obs = NULL;}
// 需要实现的观察者注册函数void subject_attach(subject_t *subject, observer_t *obs){    if (!subject->obs) {        subject->obs = obs;    } else {        observer_t *cur = subject->obs;        while (cur->next) cur = cur->next;        cur->next = obs;    }}
// 需要实现的观察者注销函数void subject_detach(subject_t *subject, observer_t *obs){    observer_t **indirect = &subject->obs; // 使用二级指针简化操作    while (*indirect) {        if (*indirect == obs) {            *indirect = obs->next; // 绕过目标节点            obs->next = NULL;      // 重置观察者的next指针            return;        }        indirect = &(*indirect)->next;    }}
// 数据通知订阅者void subject_notify(subject_t *subject, int temp, int hum){    observer_t *_obs = subject->obs;    while(_obs)    {        observer_update(_obs, temp, hum);        _obs = _obs->next;    }}

typedef struct _display_t {    observer_t obs;} display_t;
void display_show(observer_t *obs, int temp, int hum);
// 静态构造函数void display_init(display_t *display, subject_t *subject) {    observer_init(&display->obs, subject);    display->obs.update = display_show;}
// 模拟屏幕显示void display_show(observer_t *obs, int temp, int hum) {    printf("temp:%d\n", temp);    printf("hum:%d\n", hum);}
typedef struct _ble_t {    observer_t obs;} ble_t;
void ble_send(observer_t *obs, int temp, int hum);
// 静态构造函数(修正变量名错误)void ble_init(ble_t* ble, subject_t *subject) {    observer_init(&ble->obs, subject);  // 修正 display-> → ble->    ble->obs.update = ble_send;}
// 模拟蓝牙发送void ble_send(observer_t *obs, int temp, int hum) {    printf("send temp:%d\n", temp);    printf("send hum:%d\n", hum);}
typedef struct _sensor_t {    subject_t subject;    int temp;    int hum;} sensor_t;
// 静态构造函数void sensor_init(sensor_t *sensor){    sensor->temp = 0;    sensor->hum = 0;    subject_init(&sensor->subject);}
// 模拟温湿度传感器读取数值void sensor_get(sensor_t *sensor, int temp, int hum) {    sensor->temp = temp;    sensor->hum = hum;    subject_notify(&sensor->subject, temp, hum);  // 更安全的指针转换}

int main() {    // 创建传感器实例    sensor_t my_sensor;    sensor_init(&my_sensor);
    // 创建显示设备和蓝牙设备    display_t screen;    display_init(&screen, (subject_t*)&my_sensor);    ble_t ble_device;    ble_init(&ble_device, (subject_t*)&my_sensor);
    // 第一次数据更新(两个设备都应响应)    printf("=== First Update ===\n");    sensor_get(&my_sensor, 25, 60);
    // 移除蓝牙设备(通过反初始化)    printf("\n=== Detaching BLE ===\n");    observer_deinit(&ble_device.obs);
    // 第二次数据更新(仅显示设备响应)    printf("\n=== Second Update ===\n");    sensor_get(&my_sensor, 26, 58);
    return 0;}
本站声明: 本文章由作者或相关机构授权发布,目的在于传递更多信息,并不代表本站赞同其观点,本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者,如若文章内容侵犯您的权益,请及时联系本站删除( 邮箱:macysun@21ic.com )。
关闭