【设计模式】观察者模式介绍及C代码实现

背景

在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”，即一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。

假设有一个简单的应用场景，一个气象站记录当地天气的温度、湿度和气压，并将这些数据展示在一个显示屏上。现在需要实现一个气象站的应用，支持多个显示屏同时显示气象数据，这时候就可以使用观察者模式来实现。

定义

观察者模式（Observer Pattern）是一种常用的设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并更新自己的状态。观察者模式又称为发布-订阅模式。

观察者模式的主要角色包括以下几个部分：

Subject（主题）：被观察的对象，它将所有观察者对象的引用保存在一个集合中，并提供了添加和删除观察者对象的方法。

Observer（观察者）：观察者接口，定义了更新自己的状态的方法，以便主题在状态发生变化时通知观察者。

ConcreteSubject（具体主题）：具体的主题实现类，维护一个状态，并在状态发生变化时通知所有观察者。

ConcreteObserver（具体观察者）：具体的观察者实现类，实现观察者接口中定义的方法，以便在接收到主题的通知时更新自己的状态。

应用场景

观察者模式常常被用于以下场景：

一对多的依赖关系：当一个对象的状态发生变化时，需要通知多个对象，并且这些对象需要根据主题对象的状态进行相应的处理，这时可以使用观察者模式。
发布-订阅模型：观察者模式也被称为发布-订阅模型。在这个模型中，主题对象充当发布者的角色，而观察者充当订阅者的角色。主题对象不需要知道具体的观察者，只需要通知所有的观察者即可。
GUI 事件处理：在 GUI 编程中，经常使用观察者模式来处理用户界面事件。例如，当用户点击按钮时，程序会通知所有的事件监听器来处理该事件。
网络编程：在网络编程中，经常使用观察者模式来实现异步通信。例如，当客户端连接服务器时，服务器会通知所有的客户端连接已建立。

总之，当一个对象的状态发生变化时，需要通知多个对象，并且这些对象需要根据主题对象的状态进行相应的处理时，可以使用观察者模式。观察者模式可以帮助我们降低系统的耦合度，增强系统的灵活性和可维护性。

模式结构

在这里插入图片描述

实现步骤

观察者模式的实现步骤如下：

定义 Subject 接口，该接口定义了注册观察者、删除观察者和通知观察者的方法。
定义 Observer 接口，该接口定义了观察者需要实现的方法。
定义具体主题类 ConcreteSubject，实现 Subject 接口，并包含观察者列表。具体主题类负责管理观察者列表，并在状态发生改变时通知观察者。
定义具体观察者类 ConcreteObserver，实现 Observer 接口，并在 update 方法中更新自己的状态。
在具体主题类中实现注册观察者、删除观察者和通知观察者的方法。
在具体观察者类中实现 update 方法，当主题对象的状态发生改变时，观察者会接收到通知并更新自己的状态。
在客户端代码中创建具体主题对象和具体观察者对象，并将观察者注册到主题对象中。
当主题对象的状态发生改变时，观察者会接收到通知并更新自己的状态，从而实现观察者模式的功能。

观察者模式的核心思想是将主题和观察者解耦，使得它们可以独立地变化。主题对象负责管理状态和通知观察者，而观察者对象负责更新自己的状态。观察者模式可以帮助我们降低系统的耦合度，增强系统的灵活性和可维护性。

C语言代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义观察者接口
typedef struct _Observer {
    void (*update)(struct _Observer* self);
} Observer;

// 定义主题接口
typedef struct _Subject {
    void (*registerObserver)(struct _Subject* self, Observer* observer);
    void (*removeObserver)(struct _Subject* self, Observer* observer);
    void (*notifyObservers)(struct _Subject* self);
} Subject;

// 定义具体观察者类
typedef struct _ConcreteObserver {
    Observer base;
    char name[20];
} ConcreteObserver;

// 定义具体主题类
typedef struct _ConcreteSubject {
    Subject base;
    Observer* observers[10];
    int count;
    int state;
} ConcreteSubject;

// 实现具体观察者类的更新方法
void ConcreteObserver_update(Observer* self) {
    ConcreteObserver* observer = (ConcreteObserver*)self;
    printf("%s: state changed\n", observer->name);
}

// 实现具体主题类的注册观察者方法
void ConcreteSubject_registerObserver(Subject* self, Observer* observer) {
    ConcreteSubject* subject = (ConcreteSubject*)self;
    if (subject->count < 10) {
        subject->observers[subject->count++] = observer;
    }
}

// 实现具体主题类的删除观察者方法
void ConcreteSubject_removeObserver(Subject* self, Observer* observer) {
    ConcreteSubject* subject = (ConcreteSubject*)self;
    for (int i = 0; i < subject->count; i++) {
        if (subject->observers[i] == observer) {
            for (int j = i; j < subject->count - 1; j++) {
                subject->observers[j] = subject->observers[j + 1];
            }
            subject->count--;
            break;
        }
    }
}

// 实现具体主题类的通知观察者方法
void ConcreteSubject_notifyObservers(Subject* self) {
    ConcreteSubject* subject = (ConcreteSubject*)self;
    for (int i = 0; i < subject->count; i++) {
        subject->observers[i]->update(subject->observers[i]);
    }
}

int main() {
    // 创建具体主题对象
    ConcreteSubject subject;
    memset(&subject, 0, sizeof(ConcreteSubject));
    subject.base.registerObserver = ConcreteSubject_registerObserver;
    subject.base.removeObserver = ConcreteSubject_removeObserver;
    subject.base.notifyObservers = ConcreteSubject_notifyObservers;

    // 创建具体观察者对象
    ConcreteObserver observer1, observer2;
    memset(&observer1, 0, sizeof(ConcreteObserver));
    memset(&observer2, 0, sizeof(ConcreteObserver));
    observer1.base.update = ConcreteObserver_update;
    observer2.base.update = ConcreteObserver_update;
    strcpy(observer1.name, "Observer 1");
    strcpy(observer2.name, "Observer 2");

    // 注册观察者
    subject.base.registerObserver(&subject.base, (Observer*)&observer1);
    subject.base.registerObserver(&subject.base, (Observer*)&observer2);

    // 改变主题对象的状态
    subject.state = 1;

    // 通知观察者
    subject.base.notifyObservers(&subject.base);

    // 删除观察者

总结

使用面向对象的抽象， Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达致松耦合。
目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。
观察者自己决定是否需要订阅通知，目标对象对此一无所知。
观察者模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分。