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

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

背景

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

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

定义

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

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

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

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

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

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

应用场景

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

1. 一对多的依赖关系：当一个对象的状态发生变化时，需要通知多个对象，并且这些对象需要根据主题对象的状态进行相应的处理，这时可以使用观察者模式。

2. 发布-订阅模型：观察者模式也被称为发布-订阅模型。在这个模型中，主题对象充当发布者的角色，而观察者充当订阅者的角色。主题对象不需要知道具体的观察者，只需要通知所有的观察者即可。

3. GUI 事件处理：在 GUI 编程中，经常使用观察者模式来处理用户界面事件。例如，当用户点击按钮时，程序会通知所有的事件监听器来处理该事件。

4. 网络编程：在网络编程中，经常使用观察者模式来实现异步通信。例如，当客户端连接服务器时，服务器会通知所有的客户端连接已建立。

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

模式结构

实现步骤

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

1. 定义 Subject 接口，该接口定义了注册观察者、删除观察者和通知观察者的方法。

2. 定义 Observer 接口，该接口定义了观察者需要实现的方法。

3. 定义具体主题类 ConcreteSubject，实现 Subject 接口，并包含观察者列表。具体主题类负责管理观察者列表，并在状态发生改变时通知观察者。

4. 定义具体观察者类 ConcreteObserver，实现 Observer 接口，并在 update 方法中更新自己的状态。

5. 在具体主题类中实现注册观察者、删除观察者和通知观察者的方法。

6. 在具体观察者类中实现 update 方法，当主题对象的状态发生改变时，观察者会接收到通知并更新自己的状态。

7. 在客户端代码中创建具体主题对象和具体观察者对象，并将观察者注册到主题对象中。

8. 当主题对象的状态发生改变时，观察者会接收到通知并更新自己的状态，从而实现观察者模式的功能。

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

C语言代码示例

#include 
#include 
#include 

// 定义观察者接口
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模式的一个重要组成部分。