Golang 实现观察者模式的事件管理库

观察者模式是一种常用的设计模式，它定义了对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知并自动更新。下面我将介绍如何使用Golang实现一个简单但功能完备的事件管理库。

基本实现

package event

import (
	"sync"
)

// EventHandler 事件处理函数类型
type EventHandler func(interface{})

// Event 事件结构体
type Event struct {
	handlers []EventHandler
	mu       sync.RWMutex
}

// NewEvent 创建新事件
func NewEvent() *Event {
	return &Event{
		handlers: make([]EventHandler, 0),
	}
}

// Subscribe 订阅事件
func (e *Event) Subscribe(handler EventHandler) {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.handlers = append(e.handlers, handler)
}

// Unsubscribe 取消订阅
func (e *Event) Unsubscribe(handler EventHandler) {
	e.mu.Lock()
	defer e.mu.Unlock()
	for i, h := range e.handlers {
		if &h == &handler {
			e.handlers = append(e.handlers[:i], e.handlers[i+1:]...)
			break
		}
	}
}

// Emit 触发事件
func (e *Event) Emit(data interface{}) {
	e.mu.RLock()
	defer e.mu.RUnlock()
	for _, handler := range e.handlers {
		go handler(data) // 使用goroutine异步处理
	}
}

使用示例

package main

import (
	"fmt"
	"time"
	"./event" // 替换为你的event包路径
)

func main() {
	// 创建事件
	loginEvent := event.NewEvent()

	// 订阅者1
	subscriber1 := func(data interface{}) {
		user, ok := data.(string)
		if !ok {
			return
		}
		fmt.Printf("Subscriber1: 用户 %s 登录了\n", user)
	}

	// 订阅者2
	subscriber2 := func(data interface{}) {
		user, ok := data.(string)
		if !ok {
			return
		}
		fmt.Printf("Subscriber2: 检测到 %s 登录\n", user)
	}

	// 订阅事件
	loginEvent.Subscribe(subscriber1)
	loginEvent.Subscribe(subscriber2)

	// 模拟用户登录
	fmt.Println("用户admin登录中...")
	loginEvent.Emit("admin")

	// 等待goroutine执行
	time.Sleep(100 * time.Millisecond)

	// 取消订阅
	loginEvent.Unsubscribe(subscriber1)

	// 再次触发事件
	fmt.Println("\n用户guest登录中...")
	loginEvent.Emit("guest")

	time.Sleep(100 * time.Millisecond)
}

高级功能扩展

1. 带优先级的事件处理

type PriorityHandler struct {
	Handler  EventHandler
	Priority int // 优先级，数字越小优先级越高
}

type Event struct {
	handlers []PriorityHandler
	mu       sync.RWMutex
}

func (e *Event) SubscribeWithPriority(handler EventHandler, priority int) {
	e.mu.Lock()
	defer e.mu.Unlock()
	
	ph := PriorityHandler{
		Handler:  handler,
		Priority: priority,
	}
	
	// 按优先级插入
	for i, h := range e.handlers {
		if priority < h.Priority {
			e.handlers = append(e.handlers[:i], append([]PriorityHandler{ph}, e.handlers[i:]...)...)
			return
		}
	}
	
	e.handlers = append(e.handlers, ph)
}

2. 同步/异步触发控制

func (e *Event) EmitSync(data interface{}) {
	e.mu.RLock()
	defer e.mu.RUnlock()
	for _, handler := range e.handlers {
		handler(data) // 同步处理
	}
}

func (e *Event) EmitAsync(data interface{}) {
	e.mu.RLock()
	handlers := make([]EventHandler, len(e.handlers))
	copy(handlers, e.handlers)
	e.mu.RUnlock()
	
	for _, handler := range handlers {
		go handler(data) // 异步处理
	}
}

3. 事件总线实现

type EventBus struct {
	events map[string]*Event
	mu     sync.RWMutex
}

func NewEventBus() *EventBus {
	return &EventBus{
		events: make(map[string]*Event),
	}
}

func (eb *EventBus) Subscribe(eventName string, handler EventHandler) {
	eb.mu.Lock()
	defer eb.mu.Unlock()
	
	if _, ok := eb.events[eventName]; !ok {
		eb.events[eventName] = NewEvent()
	}
	
	eb.events[eventName].Subscribe(handler)
}

func (eb *EventBus) Emit(eventName string, data interface{}) {
	eb.mu.RLock()
	defer eb.mu.RUnlock()
	
	if event, ok := eb.events[eventName]; ok {
		event.Emit(data)
	}
}

使用建议

1. 命名规范：事件名称应使用清晰、明确的命名，如UserLoggedIn、OrderCreated等
2. 错误处理：在事件处理函数中添加recover机制防止单个处理函数崩溃影响整体
3. 性能考虑：对于高频事件，考虑使用对象池减少GC压力
4. 测试：确保编写单元测试覆盖各种场景

这个事件管理库提供了观察者模式的基本实现，可以根据项目需求进一步扩展功能。它解耦了事件发布者和订阅者，使系统更加灵活和可维护。