feat: 初始化多机器人服务端项目框架

基于Go语言构建多机器人服务端框架，包含配置管理、事件总线、依赖注入等核心模块
添加项目基础结构、README、gitignore和初始代码实现

internal/engine/dispatcher.go

@@ -0,0 +1,162 @@
+package engine
+
+import (
+	"context"
+	"sort"
+
+	"cellbot/internal/protocol"
+	"go.uber.org/zap"
+)
+
+// Dispatcher 事件分发器
+// 管理事件处理器并按照优先级分发事件
+type Dispatcher struct {
+	handlers []protocol.EventHandler
+	middlewares []protocol.Middleware
+	logger   *zap.Logger
+	eventBus *EventBus
+}
+
+// NewDispatcher 创建事件分发器
+func NewDispatcher(eventBus *EventBus, logger *zap.Logger) *Dispatcher {
+	return &Dispatcher{
+		handlers:    make([]protocol.EventHandler, 0),
+		middlewares: make([]protocol.Middleware, 0),
+		logger:      logger.Named("dispatcher"),
+		eventBus:    eventBus,
+	}
+}
+
+// RegisterHandler 注册事件处理器
+func (d *Dispatcher) RegisterHandler(handler protocol.EventHandler) {
+	d.handlers = append(d.handlers, handler)
+	// 按优先级排序(数值越小优先级越高)
+	sort.Slice(d.handlers, func(i, j int) bool {
+		return d.handlers[i].Priority() < d.handlers[j].Priority()
+	})
+
+	d.logger.Debug("Handler registered",
+		zap.Int("priority", handler.Priority()),
+		zap.Int("total_handlers", len(d.handlers)))
+}
+
+// UnregisterHandler 取消注册事件处理器
+func (d *Dispatcher) UnregisterHandler(handler protocol.EventHandler) {
+	for i, h := range d.handlers {
+		if h == handler {
+			d.handlers = append(d.handlers[:i], d.handlers[i+1:]...)
+			break
+		}
+	}
+	d.logger.Debug("Handler unregistered",
+		zap.Int("total_handlers", len(d.handlers)))
+}
+
+// RegisterMiddleware 注册中间件
+func (d *Dispatcher) RegisterMiddleware(middleware protocol.Middleware) {
+	d.middlewares = append(d.middlewares, middleware)
+	d.logger.Debug("Middleware registered",
+		zap.Int("total_middlewares", len(d.middlewares)))
+}
+
+// Start 启动分发器
+func (d *Dispatcher) Start(ctx context.Context) {
+	// 订阅所有类型的事件
+	for _, eventType := range []protocol.EventType{
+		protocol.EventTypeMessage,
+		protocol.EventTypeNotice,
+		protocol.EventTypeRequest,
+		protocol.EventTypeMeta,
+	} {
+		eventChan := d.eventBus.Subscribe(eventType, nil)
+		go d.eventLoop(ctx, eventChan)
+	}
+
+	d.logger.Info("Dispatcher started")
+}
+
+// Stop 停止分发器
+func (d *Dispatcher) Stop() {
+	d.logger.Info("Dispatcher stopped")
+}
+
+// eventLoop 事件循环
+func (d *Dispatcher) eventLoop(ctx context.Context, eventChan chan protocol.Event) {
+	for {
+		select {
+		case event, ok := <-eventChan:
+			if !ok {
+				return
+			}
+			d.handleEvent(ctx, event)
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// handleEvent 处理单个事件
+func (d *Dispatcher) handleEvent(ctx context.Context, event protocol.Event) {
+	d.logger.Debug("Processing event",
+		zap.String("type", string(event.GetType())),
+		zap.String("detail_type", event.GetDetailType()))
+
+	// 通过中间件链处理事件
+	next := d.createHandlerChain(ctx, event)
+
+	// 执行中间件链
+	if len(d.middlewares) > 0 {
+		d.executeMiddlewares(ctx, event, func(ctx context.Context, e protocol.Event) error {
+			next(ctx, e)
+			return nil
+		})
+	} else {
+		next(ctx, event)
+	}
+}
+
+// createHandlerChain 创建处理器链
+func (d *Dispatcher) createHandlerChain(ctx context.Context, event protocol.Event) func(context.Context, protocol.Event) {
+	return func(ctx context.Context, e protocol.Event) {
+		for _, handler := range d.handlers {
+			if handler.Match(event) {
+				if err := handler.Handle(ctx, e); err != nil {
+					d.logger.Error("Handler execution failed",
+						zap.Error(err),
+						zap.String("event_type", string(e.GetType())))
+				}
+			}
+		}
+	}
+}
+
+// executeMiddlewares 执行中间件链
+func (d *Dispatcher) executeMiddlewares(ctx context.Context, event protocol.Event, next func(context.Context, protocol.Event) error) {
+	// 从后向前构建中间件链
+	handler := next
+	for i := len(d.middlewares) - 1; i >= 0; i-- {
+		middleware := d.middlewares[i]
+		currentHandler := handler
+		handler = func(ctx context.Context, e protocol.Event) error {
+			if err := middleware.Process(ctx, e, currentHandler); err != nil {
+				d.logger.Error("Middleware execution failed",
+					zap.Error(err),
+					zap.String("event_type", string(e.GetType())))
+			}
+			return nil
+		}
+	}
+
+	// 执行中间件链
+	handler(ctx, event)
+}
+
+// GetHandlerCount 获取处理器数量
+func (d *Dispatcher) GetHandlerCount() int {
+	return len(d.handlers)
+}
+
+// GetMiddlewareCount 获取中间件数量
+func (d *Dispatcher) GetMiddlewareCount() int {
+	return len(d.middlewares)
+}