观察者模式

码事漫谈

发布于 2024-12-20 12:45:43

20200

代码可运行

文章被收录于专栏：设计模式设计模式

运行总次数：0

代码可运行

观察者模式详解

定义

观察者模式（Observer Pattern）是一种行为型设计模式，用于定义对象间的一对多依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会自动收到通知并更新。这种模式主要用于实现发布-订阅机制。

观察者模式的结构

核心角色

主题（Subject）：被观察的对象，包含多个观察者。它提供注册、注销和通知观察者的方法。
观察者（Observer）：依赖于主题的对象，当主题发生变化时，观察者会收到通知并更新自己的状态。
具体主题（Concrete Subject）：实现了通知机制的具体对象，它在状态变化时通知所有注册的观察者。
具体观察者（Concrete Observer）：每个观察者响应主题的状态变化，并进行相应的操作。

使用案例

案例 1：气象站数据更新

多个显示设备（例如手机、电视、天气站）都订阅气象站，当气象数据更新时，它们自动显示最新信息。

案例 2：股票价格监控

多个投资者或应用程序监控股票价格，当价格变化时，所有订阅者会收到通知并做出反应。

案例 3：用户界面组件更新

UI组件（如按钮、文本框）观察模型数据，当模型数据变化时，UI组件会自动更新，保持一致。

观察者模式的优缺点

优点

低耦合：观察者与主题之间是松耦合的，观察者并不依赖于主题的具体实现。
动态添加观察者：可以在运行时动态添加或移除观察者，灵活性高。
自动更新：当主题状态发生变化时，所有观察者会自动得到更新通知。

缺点

可能引起过多更新：如果观察者过多，频繁的通知可能带来性能问题。
不适合同步通知：如果观察者之间有较强依赖关系，直接通知可能导致不一致性。
可能会造成内存泄漏：如果没有正确管理观察者的生命周期，可能会导致观察者未能正确注销。

观察者模式的结构图

观察者模式的实现

C++ 实现

#include <iostream>
#include <vector>
#include <memory>

// 抽象观察者
class Observer {
public:
    virtual void Update(int state) = 0;
    virtual ~Observer() = default;
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    int state;
public:
    void Update(int newState) override {
        state = newState;
        std::cout << "Observer state updated to: " << state << std::endl;
    }
};

// 抽象主题
class Subject {
public:
    virtual void Attach(std::shared_ptr<Observer> observer) = 0;
    virtual void Detach(std::shared_ptr<Observer> observer) = 0;
    virtual void Notify() = 0;
    virtual ~Subject() = default;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<std::shared_ptr<Observer>> observers;
    int state;
public:
    void Attach(std::shared_ptr<Observer> observer) override {
        observers.push_back(observer);
    }

    void Detach(std::shared_ptr<Observer> observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void Notify() override {
        for (auto& observer : observers) {
            observer->Update(state);
        }
    }

    void SetState(int newState) {
        state = newState;
        Notify();
    }
};

// 客户端代码
int main() {
    auto subject = std::make_shared<ConcreteSubject>();
    auto observer1 = std::make_shared<ConcreteObserver>();
    auto observer2 = std::make_shared<ConcreteObserver>();

    subject->Attach(observer1);
    subject->Attach(observer2);

    subject->SetState(1); // 更新状态并通知观察者

    return 0;
}

C# 实现

using System;
using System.Collections.Generic;

// 抽象观察者
public interface IObserver {
    void Update(int state);
}

// 具体观察者
public class ConcreteObserver : IObserver {
    private int state;
    public void Update(int newState) {
        state = newState;
        Console.WriteLine($"Observer state updated to: {state}");
    }
}

// 抽象主题
public interface ISubject {
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

// 具体主题
public class ConcreteSubject : ISubject {
    private List<IObserver> observers = new List<IObserver>();
    private int state;

    public void Attach(IObserver observer) {
        observers.Add(observer);
    }

    public void Detach(IObserver observer) {
        observers.Remove(observer);
    }

    public void Notify() {
        foreach (var observer in observers) {
            observer.Update(state);
        }
    }

    public void SetState(int newState) {
        state = newState;
        Notify();
    }
}

// 客户端代码
class Program {
    static void Main(string[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();

        subject.Attach(observer1);
        subject.Attach(observer2);

        subject.SetState(1);  // 更新状态并通知观察者
    }
}

观察者模式的优缺点对比

特性	优点	缺点
松耦合	观察者和主题之间解耦，可以动态添加观察者	如果观察者过多，可能导致性能下降
灵活性	允许主题对象在运行时增加或删除观察者	不适合复杂的同步通知
自动更新	主题状态变化时自动通知观察者	如果没有正确管理生命周期，可能会导致内存泄漏