编程练习：编写一个监听者模式类

监听者模式（Observer Pattern）是一种行为设计模式，它定义了对象之间的一对多依赖关系。当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。这种模式非常适合用于事件驱动的系统，例如 GUI 框架、消息队列等。

在本文中，我们将通过编写一个简单的监听者模式类 Observable，来学习如何实现这一设计模式。

---

1. 监听者模式的核心概念

监听者模式通常包含以下两个核心组件：

• Subject（主题）：维护一个观察者列表，并提供注册、注销和通知观察者的接口。

• Observer（观察者）：定义一个更新接口，用于接收主题的通知。

在我们的实现中，Observable 类充当 Subject 的角色，而观察者是一个 std::function<void()> 回调函数。

---

2. 实现 Observable 类

以下是 Observable 类的完整实现：

#ifndef __OBSERVABLE_H___
#define __OBSERVABLE_H___

#include <functional>
#include <mutex>
#include <unordered_map>
#include <cassert>

namespace cise {

/**
 * @class Observable
 * @brief 观察者模式中的可观察对象，允许观察者注册、注销和接收通知。
 * 
 * @tparam Event 观察事件的类型，可以是任意可哈希的类型（如枚举、整数、字符串等）。
 */
template<typename Event>
class Observable final {
public:
    using Handle = int;  // 观察者句柄类型

public:
    Observable() : nextHandle_(0) {}

    /**
     * @brief 添加观察者。
     * 
     * @param event 观察事件的键值。
     * @param callback 观察者的回调函数。
     * @return 返回观察者的句柄，用于后续注销。
     */
    Handle addObserver(Event event, std::function<void()> callback) {
        std::lock_guard<std::mutex> lock(mutex_);

        // 检查 Handle 是否溢出
        assert(nextHandle_ < std::numeric_limits<Handle>::max() && "Handle overflow: maximum number of observers reached.");

        auto& handlers = observers_[event];
        handlers[nextHandle_] = std::move(callback);
        return nextHandle_++;
    }

    /**
     * @brief 移除指定事件和句柄的观察者。
     * 
     * @param event 观察事件的键值。
     * @param handle 观察者的句柄。
     */
    void removeObserver(Event event, Handle handle) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = observers_.find(event);
        if (it != observers_.end()) {
            it->second.erase(handle);
        }
    }

    /**
     * @brief 移除所有事件下指定句柄的观察者。
     * 
     * @param handle 观察者的句柄。
     */
    void removeObserver(Handle handle) {
        std::lock_guard<std::mutex> lock(mutex_);
        for (auto& [event, handlers] : observers_) {
            handlers.erase(handle);
        }
    }

    /**
     * @brief 通知所有观察指定事件的观察者。
     * 
     * @param event 观察事件的键值。
     * @note 如果某个观察者的回调函数抛出异常，异常会直接传递给调用者。
     */
    void notifyObservers(Event event) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = observers_.find(event);
        if (it != observers_.end()) {
            for (auto& [handle, callback] : it->second) {
                callback();  // 异常会直接传递给调用者
            }
        }
    }

private:
    // 使用 std::unordered_map 而不是 std::map，因为90%场景不需要按事件键值有序遍历观察者，有利于提高性能。
    std::unordered_map<Event, std::unordered_map<Handle, std::function<void()>>> observers_;
    Handle nextHandle_;
    std::mutex mutex_;
};

}  // namespace cise

#endif // __OBSERVABLE_H___

---

3. 设计亮点

3.1 线程安全

使用 std::mutex 保护共享资源，确保在多线程环境下安全地添加、移除和通知观察者。

3.2 高性能

使用 std::unordered_map 存储观察者，避免了有序遍历的开销，提高了性能。

3.3 灵活性

支持任意可哈希的事件类型（如枚举、整数、字符串等），适用于多种场景。

3.4 异常处理

将异常直接传递给调用者，遵循"谁调用，谁处理"的原则。

---

4. 使用示例

以下是一个简单的使用示例：

#include <iostream>
#include "Observable.h"

int main() {
    cise::Observable<std::string> observable;

    // 添加观察者
    auto handle1 = observable.addObserver("event1", []() {
        std::cout << "Observer 1: Event 1 triggered!" << std::endl;
    });

    auto handle2 = observable.addObserver("event2", []() {
        std::cout << "Observer 2: Event 2 triggered!" << std::endl;
    });

    // 通知观察者
    observable.notifyObservers("event1");  // 输出: Observer 1: Event 1 triggered!
    observable.notifyObservers("event2");  // 输出: Observer 2: Event 2 triggered!

    // 移除观察者
    observable.removeObserver("event1", handle1);
    observable.notifyObservers("event1");  // 无输出，观察者已移除

    return 0;
}

---

5. 单元测试

为了确保 Observable 类的正确性，我们编写了以下单元测试：

#include <gtest/gtest.h>
#include "Observable.h"

using namespace cise;

TEST(ObservableTest, AddAndNotifyObserver) {
    Observable<std::string> observable;

    bool isCalled = false;
    auto handle = observable.addObserver("event1", [&isCalled]() {
        isCalled = true;
    });

    observable.notifyObservers("event1");
    EXPECT_TRUE(isCalled);
}

TEST(ObservableTest, RemoveObserverByEvent) {
    Observable<std::string> observable;

    bool isCalled = false;
    auto handle = observable.addObserver("event1", [&isCalled]() {
        isCalled = true;
    });

    observable.removeObserver("event1", handle);
    observable.notifyObservers("event1");
    EXPECT_FALSE(isCalled);
}

TEST(ObservableTest, NotifyWithException) {
    Observable<std::string> observable;

    observable.addObserver("event1", []() {
        throw std::runtime_error("Callback failed");
    });

    EXPECT_THROW(observable.notifyObservers("event1"), std::runtime_error);
}

Makefile:

# 编译器
CXX = g++

# 编译选项
CXXFLAGS = -std=c++11 -Wall -Wextra -g -pthread

# Google Test 路径（根据你的安装路径修改）
GTEST_DIR = /path/to/gtest

# 目标文件
TARGET = observable_test

# 源文件
SRCS = ObservableTest.cpp Observable.h

# 编译规则
$(TARGET): $(SRCS)
    $(CXX) $(CXXFLAGS) -isystem $(GTEST_DIR)/include -I$(GTEST_DIR) \
    $(GTEST_DIR)/libgtest.a $(GTEST_DIR)/libgtest_main.a \
    $(SRCS) -o $(TARGET)

# 运行测试
test: $(TARGET)
    ./$(TARGET)

# 清理
clean:
    rm -f $(TARGET)

示例目录结构

假设你的项目目录结构如下：
复制

/project
    ├── Observable.h
    ├── ObservableTest.cpp
    ├── Makefile
    └── /gtest (Google Test 安装路径)

---

运行示例

1. 编译：

   make

2. 运行测试：

   make test

3. 清理：

   make clean

---

6. 总结

通过本次编程练习，我们实现了一个简单但功能强大的监听者模式类 Observable。它不仅支持多线程环境，还具有高性能和灵活性。希望这篇文章能帮助你更好地理解监听者模式，并在实际项目中应用它。

如果你有任何问题或建议，欢迎在评论区留言！

---

参考资料

• Observer Pattern - Wikipedia

• C++ Standard Library Documentation