✨ encapsulate object storage service operations

common/storage/events/dispatcher.go

@@ -0,0 +1,166 @@
+package events
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+)
+
+// Event 定义事件类型
+type Event struct {
+	Name string      // 事件名称
+	Data interface{} // 事件数据
+}
+
+// EventHandler 定义事件处理器函数类型
+type EventHandler func(event Event)
+
+// Dispatcher 接口定义事件分发器
+type Dispatcher interface {
+	Register(eventName string, handler EventHandler)            // 注册事件处理器
+	RegisterOnce(eventName string, handler EventHandler)        // 注册一次性事件处理器
+	Dispatch(event Event)                                       // 分发事件
+	RemoveHandler(eventName string, handler EventHandler) error // 移除特定处理器
+	ClearHandlers(eventName string)                             // 清除某事件的所有处理器
+}
+
+// defaultDispatcher 默认事件分发器实现
+type defaultDispatcher struct {
+	handlers map[string][]EventHandler
+	once     map[string]map[*EventHandler]struct{} // 使用指针作为 map 键
+	mu       sync.RWMutex
+}
+
+// NewDispatcher 创建新的事件分发器
+func NewDispatcher() Dispatcher {
+	return &defaultDispatcher{
+		handlers: make(map[string][]EventHandler),
+		once:     make(map[string]map[*EventHandler]struct{}), // 修改为指针
+	}
+}
+
+// Register 注册事件处理器
+func (d *defaultDispatcher) Register(eventName string, handler EventHandler) {
+	if eventName == "" || handler == nil {
+		return
+	}
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	d.handlers[eventName] = append(d.handlers[eventName], handler)
+}
+
+// RegisterOnce 注册一次性事件处理器
+func (d *defaultDispatcher) RegisterOnce(eventName string, handler EventHandler) {
+	if eventName == "" || handler == nil {
+		return
+	}
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	// 如果还未初始化一次性处理器记录表，则初始化
+	if _, exists := d.once[eventName]; !exists {
+		d.once[eventName] = make(map[*EventHandler]struct{}) // 修改为指针
+	}
+	d.once[eventName][&handler] = struct{}{}
+
+	// 追加处理器
+	d.handlers[eventName] = append(d.handlers[eventName], handler)
+}
+
+// Dispatch 分发事件
+func (d *defaultDispatcher) Dispatch(event Event) {
+	if event.Name == "" {
+		return
+	}
+
+	d.mu.RLock()
+	handlers := d.handlers[event.Name]
+	onceHandlers := d.once[event.Name]
+	d.mu.RUnlock()
+
+	if len(handlers) == 0 {
+		fmt.Printf("No handlers registered for event: %s\n", event.Name)
+		return
+	}
+
+	var wg sync.WaitGroup
+
+	for _, handler := range handlers {
+		wg.Add(1)
+		go func(h EventHandler) {
+			defer wg.Done()
+			h(event)
+		}(handler)
+	}
+
+	wg.Wait() // 等待所有处理器执行完毕
+
+	// 移除已执行的一次性处理器
+	if len(onceHandlers) > 0 {
+		d.mu.Lock()
+		defer d.mu.Unlock()
+
+		remainingHandlers := make([]EventHandler, 0, len(handlers))
+		for _, handler := range handlers {
+			if _, exists := onceHandlers[&handler]; !exists {
+				remainingHandlers = append(remainingHandlers, handler)
+			} else {
+				delete(d.once[event.Name], &handler)
+			}
+		}
+		d.handlers[event.Name] = remainingHandlers
+	}
+}
+
+// contains 检查事件处理器是否在一次性处理器中
+func contains(onceHandlers map[*EventHandler]struct{}, handler *EventHandler) bool {
+	handlerAddr := reflect.ValueOf(handler).Pointer()
+	for onceHandler := range onceHandlers {
+		if reflect.ValueOf(onceHandler).Pointer() == handlerAddr {
+			return true
+		}
+	}
+	return false
+}
+
+// RemoveHandler 移除特定处理器
+func (d *defaultDispatcher) RemoveHandler(eventName string, handler EventHandler) error {
+	if eventName == "" || handler == nil {
+		return fmt.Errorf("invalid event name or handler")
+	}
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	handlers, exists := d.handlers[eventName]
+	if !exists {
+		return fmt.Errorf("event %s not found", eventName)
+	}
+
+	// 过滤掉需要移除的处理器
+	updatedHandlers := handlers[:0]
+	for _, h := range handlers {
+		if &h != &handler {
+			updatedHandlers = append(updatedHandlers, h)
+		}
+	}
+	d.handlers[eventName] = updatedHandlers
+
+	return nil
+}
+
+// ClearHandlers 清除某事件的所有处理器
+func (d *defaultDispatcher) ClearHandlers(eventName string) {
+	if eventName == "" {
+		return
+	}
+
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	delete(d.handlers, eventName)
+	delete(d.once, eventName)
+}

common/storage/events/handlers.go

@@ -0,0 +1,13 @@
+package events
+
+import (
+	"fmt"
+)
+
+func LogHandler(event Event) {
+	fmt.Printf("[LOG] Event: %s, Data: %+v\n", event.Name, event.Data)
+}
+
+func NotifyHandler(event Event) {
+	fmt.Printf("[NOTIFY] User notified about event: %s\n", event.Name)
+}