观察者模式（Observer Pattern）是一种经典的设计模式，广泛应用于需要处理一对多依赖关系的场景。本文将以教学风格，结合一个贴近生活的例子——智能家居设备状态监控，详细讲解观察者模式的概念、Go 语言实现、运行逻辑以及优化方向。无论你是设计模式新手还是 Go 语言爱好者，这篇文章都将为你提供清晰且实用的指导。
什么是观察者模式？
定义
观察者模式定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会得到通知并自动更新。它就像“订阅-发布”机制：你订阅了报纸，报纸更新时会送到你家。
在观察者模式中，有两个核心角色：
- 主题（Subject）：维护一组观察者，提供添加、删除观察者的方法，并在状态变化时通知所有观察者。
- 观察者（Observer）：定义一个更新接口，当主题状态变化时，观察者通过该接口接收通知并执行相应操作。
现实类比
想象一个智能家居系统：
- 智能温控器（主题）实时监测室内温度。
- 手机App、智能空调、语音助手（观察者）订阅了温控器的状态变化。
- 当温度超过 30°C 时，温控器通知所有观察者：
- 手机App推送“高温警告”。
- 智能空调自动开启制冷。
- 语音助手播报“当前温度过高”。
这个场景完美体现了观察者模式的“一对多”关系和松耦合设计。
核心思想
观察者模式的核心是解耦：
- 主题只需知道观察者实现了某个接口，无需了解其具体实现。
- 观察者只需关注主题的状态变化，无需了解其他观察者的存在。
用 Go 语言实现观察者模式
为什么选择 Go？
Go 语言以简洁、高效著称，虽然没有传统面向对象语言的继承机制，但通过接口和结构体可以优雅地实现设计模式。此外，Go 的并发特性（如 goroutine 和 channel）为观察者模式提供了额外的可能性。
设计智能家居监控系统
我们将实现一个智能家居系统的观察者模式：
- 主题：智能温控器（Thermostat），监控室内温度。
- 观察者：手机App、空调、语音助手，订阅温控器的温度变化。
- 行为：当温度超过 30°C 时，温控器通知所有观察者，触发各自响应。
代码实现
以下是完整的 Go 代码，包含详细注释：
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
package main
import (
"fmt"
"sync"
)
// Observer 定义观察者接口，包含 Update 方法
type Observer interface {
Update(temperature float64)
}
// Subject 定义主题接口，包含管理观察者和通知的方法
type Subject interface {
RegisterObserver(observer Observer)
RemoveObserver(observer Observer)
NotifyObservers()
}
// Thermostat 是具体主题，表示智能温控器
type Thermostat struct {
observers []Observer // 存储观察者列表
temperature float64 // 当前温度
threshold float64 // 温度阈值
mutex sync.Mutex // 确保并发安全
}
// NewThermostat 创建一个新的温控器实例
func NewThermostat(threshold float64) *Thermostat {
return &Thermostat{
threshold: threshold,
}
}
// RegisterObserver 添加观察者
func (t *Thermostat) RegisterObserver(observer Observer) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.observers = append(t.observers, observer)
}
// RemoveObserver 删除观察者
func (t *Thermostat) RemoveObserver(observer Observer) {
t.mutex.Lock()
defer t.mutex.Unlock()
for i, obs := range t.observers {
if obs == observer {
t.observers = append(t.observers[:i], t.observers[i+1:]...)
break
}
}
}
// NotifyObservers 通知所有观察者
func (t *Thermostat) NotifyObservers() {
t.mutex.Lock()
defer t.mutex.Unlock()
for _, observer := range t.observers {
observer.Update(t.temperature)
}
}
// SetTemperature 更新温度并在超过阈值时通知观察者
func (t *Thermostat) SetTemperature(temp float64) {
t.mutex.Lock()
t.temperature = temp
t.mutex.Unlock()
fmt.Printf("温控器：当前温度 %.1f°C\n", t.temperature)
if t.temperature >= t.threshold {
fmt.Println("温控器：温度超过阈值，通知所有观察者...")
t.NotifyObservers()
}
}
// PhoneApp 是具体观察者，表示手机应用
type PhoneApp struct {
name string
}
// NewPhoneApp 创建手机应用实例
func NewPhoneApp(name string) *PhoneApp {
return &PhoneApp{name: name}
}
// Update 实现 Observer 接口，处理温度更新
func (p *PhoneApp) Update(temperature float64) {
fmt.Printf("%s：收到高温警告，当前温度 %.1f°C\n", p.name, temperature)
}
// AirConditioner 是具体观察者，表示智能空调
type AirConditioner struct {
name string
}
// NewAirConditioner 创建空调实例
func NewAirConditioner(name string) *AirConditioner {
return &AirConditioner{name: name}
}
// Update 实现 Observer 接口，处理温度更新
func (a *AirConditioner) Update(temperature float64) {
fmt.Printf("%s：检测到高温 %.1f°C，自动开启制冷\n", a.name, temperature)
}
// VoiceAssistant 是具体观察者，表示语音助手
type VoiceAssistant struct {
name string
}
// NewVoiceAssistant 创建语音助手实例
func NewVoiceAssistant(name string) *VoiceAssistant {
return &VoiceAssistant{name: name}
}
// Update 实现 Observer 接口，处理温度更新
func (v *VoiceAssistant) Update(temperature float64) {
fmt.Printf("%s：播报：室内温度 %.1f°C，建议开启空调\n", v.name, temperature)
}
func main() {
// 创建温控器，设定温度阈值为 30°C
thermostat := NewThermostat(30.0)
// 创建观察者
phone := NewPhoneApp("用户手机")
ac := NewAirConditioner("客厅空调")
voice := NewVoiceAssistant("小爱助手")
// 注册观察者
thermostat.RegisterObserver(phone)
thermostat.RegisterObserver(ac)
thermostat.RegisterObserver(voice)
// 模拟温度变化
fmt.Println("模拟温度变化：")
thermostat.SetTemperature(25.0) // 正常温度
thermostat.SetTemperature(32.0) // 超过阈值，触发通知
// 移除一个观察者
fmt.Println("\n移除手机观察者后：")
thermostat.RemoveObserver(phone)
thermostat.SetTemperature(33.0) // 再次触发通知
}
|
运行结果
运行代码后，输出如下：
模拟温度变化：
温控器：当前温度 25.0°C
温控器：当前温度 32.0°C
温控器：温度超过阈值，通知所有观察者...
用户手机：收到高温警告，当前温度 32.0°C
客厅空调：检测到高温 32.0°C，自动开启制冷
小爱助手：播报：室内温度 32.0°C，建议开启空调
移除手机观察者后：
温控器：当前温度 33.0°C
温控器：温度超过阈值，通知所有观察者...
客厅空调：检测到高温 33.0°C，自动开启制冷
小爱助手：播报：室内温度 33.0°C，建议开启空调
代码解析
-
接口设计：
Observer 接口定义了 Update 方法，所有观察者必须实现。Subject 接口定义了管理观察者的方法。
-
主题实现（Thermostat）：
- 使用切片存储观察者列表。
- 使用
sync.Mutex 确保线程安全。
SetTemperature 方法在温度超过阈值时触发通知。
-
观察者实现：
- 每个观察者（
PhoneApp、AirConditioner、VoiceAssistant）独立处理通知。
-
主程序：
- 模拟了温控器的使用场景，包括注册、通知、移除观察者。
观察者模式的优缺点
优点
- 松耦合：主题和观察者通过接口交互，易于扩展。
- 动态管理：观察者可以动态添加或移除。
- 广播通信：适合一对多的通知场景。
缺点
- 通知开销：观察者过多可能导致性能问题。
- 内存泄漏：未移除的观察者可能导致内存泄漏。
- 复杂性：管理观察者列表可能增加代码复杂性。
适用场景
- 状态变化需要通知多个对象（例如 GUI 事件处理）。
- 实时数据监控（例如传感器、股票价格）。
- 发布-订阅系统（例如消息队列）。
扩展与优化
使用 Go 并发特性
可以将通知并行化，使用 goroutine：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
func (t *Thermostat) NotifyObservers() {
t.mutex.Lock()
observers := t.observers
t.mutex.Unlock()
var wg sync.WaitGroup
for _, observer := range observers {
wg.Add(1)
go func(obs Observer) {
defer wg.Done()
obs.Update(t.temperature)
}(observer)
}
wg.Wait()
}
|
添加优先级机制
为观察者添加优先级，按优先级通知。
使用 Channel 实现异步通知
通过 channel 广播状态变化，观察者通过 goroutine 监听。
总结
本文通过智能家居的例子，详细讲解了观察者模式的概念和 Go 语言实现。希望这篇文章能帮助你深入理解设计模式，并在实际项目中灵活应用。
如何运行代码
- 安装 Go 环境（建议 Go 1.18+）。
- 保存代码为
observer_pattern.go。
- 运行：
1
|
go run observer_pattern.go
|
下一步
- 尝试为观察者添加优先级或异步通知。
- 在博客留言，分享你的观察者模式应用场景！
评论 0