0%

设计模式-行为型模式-观察者模式

发表于 更新于 分类于

观察者模式 - 行为型模式的消息发布与订阅

在软件设计中，观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式的核心思想是将主题和观察者分离，使得主题对象的状态改变可以通知到所有依赖于它的观察者对象。本文将深入讨论观察者模式的概念、实现方式以及在实际应用中的使用场景。

观察者模式的概念

观察者模式（Observer Pattern）是一种行为型设计模式，其核心思想是定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式的主要角色包括主题（Subject）、具体主题（ConcreteSubject）、观察者（Observer）和具体观察者（ConcreteObserver）。

观察者模式的 UML 类图

classDiagram
    class Subject {
        + Attach(observer: Observer): void
        + Detach(observer: Observer): void
        + Notify(): void
    }

    class ConcreteSubject {
        - state: string
        - observers: List
        + GetState(): string
        + SetState(state: string): void
        + Attach(observer: Observer): void
        + Detach(observer: Observer): void
        + Notify(): void
    }

    class Observer {
        + Update(): void
    }

    class ConcreteObserver {
        - name: string
        - subject: ConcreteSubject
        + Update(): void
    }

    Subject <|.. ConcreteSubject
    Observer <|.. ConcreteObserver
    ConcreteObserver --> ConcreteSubject

观察者模式的实现方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
using System;
using System.Collections.Generic;

// 主题接口
public interface Subject
{
    void Attach(Observer observer);
    void Detach(Observer observer);
    void Notify();
}

// 具体主题类
public class ConcreteSubject : Subject
{
    private string state;
    private List<Observer> observers;

    public ConcreteSubject()
    {
        this.observers = new List<Observer>();
    }

    public string GetState()
    {
        return state;
    }

    public void SetState(string state)
    {
        this.state = state;
        Notify();
    }

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

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

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

// 观察者接口
public interface Observer
{
    void Update();
}

// 具体观察者类
public class ConcreteObserver : Observer
{
    private string name;
    private ConcreteSubject subject;

    public ConcreteObserver(string name, ConcreteSubject subject)
    {
        this.name = name;
        this.subject = subject;
    }

    public void Update()
    {
        Console.WriteLine($"Observer {name} received the updated state: {subject.GetState()}");
    }
}

观察者模式的应用场景

观察者模式适用于以下情况：

  1. 一个对象的状态改变需要通知其他对象，并且这些对象需要根据状态改变而做出相应的响应。
  2. 一个对象的改变需要同时影响其他对象，而且不知道有多少对象需要被通知。
  3. 一个对象向其他对象提供实时信息，而不知道这些对象是谁。

观察者模式的优势

  1. 解耦性强： 观察者模式将主题和观察者解耦，使得它们之间的关系更加灵活。
  2. 扩展性好： 可以在系统中很容易地增加新的观察者，扩展系统的功能。
  3. 实现消息发布与订阅： 观察者模式实现了一种简单的消息发布与订阅机制，适用于需要实现事件处理机制的场景。

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Program
{
    static void Main()
    {
        // 创建具体主题对象
        ConcreteSubject subject = new ConcreteSubject();

        // 创建具体观察者对象，并注册到主题
        ConcreteObserver observerA = new ConcreteObserver("Observer A", subject);
        ConcreteObserver observerB = new ConcreteObserver("Observer B", subject);
        subject.Attach(observerA);
        subject.Attach(observerB);

        // 设置主题状态，观察者收到通知并更新
        subject.SetState("New State");
    }
}

总结

观察者模式是一种行为型设计模式，通过定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式适用于实现消息发布与订阅、解耦主题和观察者的场景。在实际应用中，观察者模式常用于实现事件处理机制、图形界面组件的刷新等场景。