观察者模式（Observer Pattern）

概念

观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，它的所有依赖者（观察者）都会收到通知并自动更新。

思想

观察者模式的核心思想是将观察者与被观察者解耦，使得它们可以独立地进行变化。被观察者维护一个观察者列表，当自身状态发生改变时，依次通知观察者进行更新。

角色

1. Subject（主题）：被观察者接口或抽象类，定义了添加、删除和通知观察者的方法。
2. ConcreteSubject（具体主题）：具体的被观察者实现类，维护观察者列表，并在状态改变时通知观察者。
3. Observer（观察者）：观察者接口或抽象类，定义了接收通知并进行更新的方法。
4. ConcreteObserver（具体观察者）：具体的观察者实现类，实现接收通知并进行相应处理的方法。

优点

1. 松耦合：观察者模式将被观察者与观察者解耦，使它们可以独立地进行变化，增强了系统的灵活性和可扩展性。
2. 一对多通知：被观察者可以通知多个观察者对象，实现一对多的通知机制。
3. 遵循开闭原则：可以通过添加新的观察者类来扩展系统，无需修改现有代码。

缺点

1. 观察者过多时会影响性能：如果观察者过多或者观察者之间存在复杂的依赖关系，通知观察者的过程可能变得复杂且耗时。
2. 观察者顺序不确定：观察者之间的通知顺序是不确定的，可能导致观察者依赖顺序产生问题。

类图

@startuml
class Subject {
  +attach(observer: Observer): void
  +detach(observer: Observer): void
  +notify(): void
  #observers: list
}

class ConcreteSubject {
  +setState(state: string): void
  +getState(): string
  -state: string
}

class Observer {
  +update(): void
}

class ConcreteObserver {
  +update(): void
  -state: string
}

Subject o-- Observer
ConcreteSubject --> Subject
Observer <|.. ConcreteObserver
@enduml

时序图

@startuml
participant Subject
participant ConcreteSubject
participant Observer
participant ConcreteObserver

activate Subject
activate ConcreteSubject
activate Observer
ConcreteSubject -> Subject: attach(Observer)
Subject -> ConcreteSubject: observers.add(Observer)
Subject -> ConcreteSubject: notify()
ConcreteSubject -> Observer: update()
deactivate ConcreteSubject

...

@enduml

示例代码

下面是一个简单的示例代码，使用C++实现观察者模式。假设有一个具体主题（ConcreteSubject）代表一个天气站，可以设置天气状态，并通知观察者（ConcreteObserver）。

#include <iostream>
#include <vector>

class Observer {
public:
    virtual void update(const std::string& state) = 0;
};

class ConcreteObserver : public Observer {
public:
    void update(const std::string& state) override {
        std::cout << "Received weather update: " << state << std::endl;
    }
};

class Subject {
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        // Detach observer implementation
    }

    void notify(const std::string& state) {
        for (auto observer : observers) {
            observer->update(state);
        }
    }

private:
    std::vector<Observer*> observers;
};

class ConcreteSubject : public Subject {
public:
    void setState(const std::string& state) {
        this->state = state;
        notify(state);
    }

    const std::string& getState() const {
        return state;
    }

private:
    std::string state;
};

int main() {
    ConcreteSubject weatherStation;

    ConcreteObserver observer1;
    weatherStation.attach(&observer1);

    ConcreteObserver observer2;
    weatherStation.attach(&observer2);

    weatherStation.setState("Sunny");
    // Output:
    // Received weather update: Sunny
    // Received weather update: Sunny

    weatherStation.detach(&observer2);

    weatherStation.setState("Rainy");
    // Output:
    // Received weather update: Rainy

    return 0;
}

代码运行结果

Received weather update: Sunny
Received weather update: Sunny
Received weather update: Rainy

以上示例代码实现了一个简单的天气站，其中具体主题是天气站的实现类，具体观察者是天气站的观察者类。当天气状态发生改变时，天气站会通知所有注册的观察者，并更新它们的状态。在示例中，天气状态先后变为"Sunny"和"Rainy"，观察者收到相应的更新通知并输出相应的信息。