当前位置： 首页 > article >正文

Golang学习笔记_41——观察者模式

article 2025/3/4 19:46:00

Golang学习笔记_38——享元模式
Golang学习笔记_39——策略模式
Golang学习笔记_40——模版方法模式

文章目录

    • 一、核心概念
      • 1. 定义
      • 2. 解决的问题
      • 3. 核心角色
      • 4. 类图
    • 二、特点分析
    • 三、适用场景
      • 1. 股票价格监控系统
      • 2. 物联网设备状态监控
      • 3. 电商订单状态通知
    • 四、Go语言实现示例
      • 完整实现代码
      • 执行结果
    • 五、高级应用
      • 1. 异步通知机制（参考网页10）
      • 2. 事件过滤机制
    • 六、与其他模式对比
    • 七、实现建议
    • 八、典型应用

一、核心概念

1. 定义

观察者模式是一种行为型设计模式，建立对象间的一对多依赖关系，当一个对象（主题）状态改变时，自动通知所有依赖对象（观察者）。其核心特点包括：

  • 松耦合设计：主题与观察者通过接口交互（）
  • 动态订阅：运行时增减观察者（）
  • 广播通知：状态变化自动触发多对象更新（）

2. 解决的问题

  • 状态同步：多个对象需实时获取核心对象状态变化
  • 事件驱动：构建解耦的事件响应系统（）
  • 资源监控：如CPU使用率报警（）

3. 核心角色

角色作用
Subject维护观察者列表，定义注册/移除/通知方法（）
Observer定义更新接口，接收主题通知（）
ConcreteSubject实现具体状态管理和通知逻辑
ConcreteObserver实现业务响应逻辑

4. 类图

观察者模式类图

@startuml
interface Subject {
    + Register(Observer)
    + Remove(Observer)
    + Notify()
}

interface Observer {
    + Update()
}

class ConcreteSubject {
    - state: int
    + SetState(int)
}

class ConcreteObserver {
    + Update()
}

Subject <|-- ConcreteSubject
Observer <|-- ConcreteObserver
ConcreteSubject "1" *-- "0..*" Observer
@enduml

二、特点分析

优点

  1. 解耦设计：主题与观察者无直接依赖（）
  2. 动态扩展：支持运行时增减观察者（）
  3. 事件驱动：适用于异步处理场景（）

缺点

  1. 通知顺序：多个观察者的执行顺序不可控（）
  2. 循环触发：不当设计可能引发循环调用（）
  3. 性能开销：大量观察者时通知效率降低（）

三、适用场景

1. 股票价格监控系统

// 股票主题
type StockSubject struct {
    observers []Observer
    price     float64
}

func (s *StockSubject) Register(o Observer) {
    s.observers = append(s.observers, o)
}

func (s *StockSubject) Notify() {
    for _, o := range s.observers {
        o.Update(s.price)
    }
}

// 手机APP观察者
type MobileApp struct{}

func (m *MobileApp) Update(price float64) {
    fmt.Printf("手机端收到股价更新: %.2f\n", price)
}

2. 物联网设备状态监控

// 设备状态主题
type DeviceMonitor struct {
    observers []Observer
    status    string
}

func (d *DeviceMonitor) SetStatus(status string) {
    d.status = status
    d.Notify()
}

// 运维系统观察者
type OpsSystem struct{}

func (o *OpsSystem) Update(status string) {
    if status == "ERROR" {
        fmt.Println("触发告警：设备异常")
    }
}

3. 电商订单状态通知

type OrderSubject struct {
    observers []Observer
    state     string
}

func (o *OrderSubject) Ship() {
    o.state = "SHIPPED"
    o.Notify()
}

// 短信通知观察者
type SMSNotifier struct{}

func (s *SMSNotifier) Update(state string) {
    if state == "SHIPPED" {
        fmt.Println("发送物流短信通知")
    }
}

四、Go语言实现示例

示例类图

完整实现代码

package observer_demo

import (
	"fmt"
	"sync"
	"time"
)

// OrderEvent 事件结构体
type OrderEvent struct {
	OrderId     string
	Amount      float64
	PaymentTime time.Time
	UserID      string
}

// Observer 观察者接口
type Observer interface {
	Handle(event OrderEvent) error
	Name() string
}

// OrderSubject 主题接口
type OrderSubject interface {
	Subscribe(observer Observer)
	UnSubscribe(observer Observer)
	Notify(event OrderEvent)
}

// OrderService 具体主题实现
type OrderService struct {
	Observer sync.Map // 使用现成安全的Map存储观察者
	wg       sync.WaitGroup
}

func (s *OrderService) Subscribe(observer Observer) {
	s.Observer.Store(observer.Name(), observer)
}

func (s *OrderService) UnSubscribe(observer Observer) {
	s.Observer.Delete(observer.Name())
}

func (s *OrderService) Notify(event OrderEvent) {
	s.Observer.Range(func(key, value interface{}) bool {
		observer := value.(Observer)
		s.wg.Add(1)

		go func(obs Observer) {
			defer s.wg.Done()

			// 带超时控制的处理
			done := make(chan struct{})
			go func() {
				defer close(done)
				if err := retry(3, time.Second, func() error {
					return obs.Handle(event)
				}); err != nil {
					fmt.Printf("[Error] %s处理失败: %v\n", obs.Name(), err)
				}
			}()
			select {
			case <-done:
				fmt.Printf("[Info] %s处理完成\n", obs.Name())
			case <-time.After(5 * time.Second):
				fmt.Printf("[Error] %s处理超时\n", obs.Name())
			}
		}(observer)
		return true
	})
	s.wg.Wait()
}

// 重试函数
func retry(attempts int, sleep time.Duration, fn func() error) error {
	if err := fn(); err != nil {
		if attempts--; attempts > 0 {
			time.Sleep(sleep)
			return retry(attempts, sleep, fn)
		}
		return err
	}
	return nil
}

// InventoryObserver 具体观察者实现
type InventoryObserver struct {
}

func (i *InventoryObserver) Name() string {
	return "InventoryObserver"
}

func (i *InventoryObserver) Handle(event OrderEvent) error {
	// 模拟库存扣减操作
	fmt.Printf("库存系统：订单%s扣减库存，用户%s，金额%.2f\n",
		event.OrderId, event.UserID, event.Amount)
	return nil
}

// LogisticsObserver 具体观察者实现：物流业务
type LogisticsObserver struct {
}

func (l *LogisticsObserver) Name() string {
	return "LogisticsObserver"
}

func (l *LogisticsObserver) Handle(event OrderEvent) error {
	// 模拟物流操作
	fmt.Printf("物流系统：订单%s发货，用户%s，金额%.2f\n",
		event.OrderId, event.UserID, event.Amount)
	return nil
}

// UserObserver 具体观察者实现，用户服务
type UserObserver struct {
}

func (u *UserObserver) Name() string {
	return "UserObserver"
}

func (u *UserObserver) Handle(event OrderEvent) error {
	// 模拟用户服务操作
	fmt.Printf("用户服务：订单%s创建成功，用户%s，金额%.2f\n",
		event.OrderId, event.UserID, event.Amount)
	return nil
}

func test() {
	// 创建主题
	orderService := &OrderService{}
	// 创建观察者
	inventoryObserver := &InventoryObserver{}
	logisticsObserver := &LogisticsObserver{}
	userObserver := &UserObserver{}
	// 注册观察者
	orderService.Subscribe(inventoryObserver)
	orderService.Subscribe(logisticsObserver)
	orderService.Subscribe(userObserver)

	// 模拟支付成功事件
	event := OrderEvent{
		OrderId:     "20230303123456",
		Amount:      2999.00,
		PaymentTime: time.Now(),
		UserID:      "1001",
	}

	// 通知观察者
	fmt.Println("=== 开始通知观察者 ===")
	orderService.Notify(event)
	fmt.Println("=== 所有通知处理完成 ===")
}

执行结果

=== RUN   Test_test
=== 开始通知观察者 ===
物流系统：订单20230303123456发货，用户1001，金额2999.00
[Info] LogisticsObserver处理完成
用户服务：订单20230303123456创建成功，用户1001，金额2999.00
[Info] UserObserver处理完成
库存系统：订单20230303123456扣减库存，用户1001，金额2999.00
[Info] InventoryObserver处理完成
=== 所有通知处理完成 ===
--- PASS: Test_test (0.00s)
PASS

五、高级应用

1. 异步通知机制（参考网页10）

func (w *WeatherStation) asyncNotify() {
    w.mu.Lock()
    observers := make([]Observer, len(w.observers))
    copy(observers, w.observers)
    w.mu.Unlock()

    var wg sync.WaitGroup
    for _, o := range observers {
        wg.Add(1)
        go func(obs Observer) {
            defer wg.Done()
            obs.Update(w.temp)
        }(o)
    }
    wg.Wait()
}

2. 事件过滤机制

type SmartObserver struct {
    lastTemp float64
}

func (s *SmartObserver) Update(temp float64) {
    if math.Abs(temp-s.lastTemp) > 1.0 {
        fmt.Println("温度变化超过1度")
        s.lastTemp = temp
    }
}

六、与其他模式对比

模式核心区别典型场景
中介者模式通过中介协调多对象交互复杂对象间通信
责任链模式请求沿链传递 vs 广播通知审批流程处理
发布订阅引入消息代理解耦更彻底（）分布式系统消息传递

七、实现建议

  1. 线程安全：使用sync.Mutex保证并发安全（）
  2. 批量通知：使用copy避免通知过程中列表变更（见示例）
  3. 性能优化：对于大量观察者采用批处理或异步通知（）
  4. 防止泄漏：及时移除无效观察者（）

八、典型应用

  1. GUI事件处理：如按钮点击事件监听（）
  2. 微服务配置中心：配置变更通知服务集群（）
  3. 游戏引擎：玩家状态变化触发多系统响应（）

通过这种设计模式，可以构建出松耦合、易扩展的事件驱动系统。在实际Go开发中，结合channel特性还能实现更高效的观察者模式变体。


http://www.kler.cn/a/570548.html

相关文章：

  • Skynet入门（一）
  • 开源ocr
  • 19c startup ORA-00093 ORA-01078 pga_aggregate_limit
  • 千峰React:组件与逻辑封装（下）
  • Leetcode 刷题记录 01 —— 哈希
  • 医院信息科医疗语言大模型开发的风险洞察与避坑策略
  • 6.C#对接微信Native支付（退款申请、退款回调通知）
  • Kafka Connect连接器的全生命周期：
  • Pytest测试用例执行跳过的3种方式
  • 安路FPGA开发入门：软件安装与点灯与仿真（TangDynasty ModelSim）
  • 单体架构部署的缺陷：为什么现代应用需要转型？
  • yolov8训练模型、测试视频
  • 深入解析Java虚拟机（JVM）的核心组成
  • 深入探究Python机器学习算法：无监督学习(聚类算法如 K-Means、DBSCAN,降维算法如 PCA、SVD)
  • Java中常见的设计模式
  • Transformer结构和注意力机制
  • 【软件系统架构】系列三：数据库系统之三
  • linux插入模块和删除模块
  • 政务信息化项目命名有什么门道？
  • 【JAVA面试题】设计模式之原型模式