南墙上的石头头像

【企业级Agent协作网络】 第6天:消息路由与事件驱动架构

Day 06: 消息路由与事件驱动架构

概述

消息路由与事件驱动是企业Agent系统的核心通信机制,通过统一的消息路由器和事件驱动架构,实现系统各组件间的解耦和高效通信。本文将详细介绍消息路由的设计原理、事件驱动架构的实现机制和最佳实践。

消息路由架构

整体架构设计

┌─────────────────────────────────────────────────────────────┐
│                   消息路由架构                               │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
│  │   MessageRouter  │  │   EventBus      │  │   QueueManager  │ │
│  │   消息路由器     │  │    事件总线      │  │   队列管理器     │ │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
│          ↓                      ↓                      ↓     │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
│  │   RouteRegistry  │  │   EventHandlers │  │   QueueWorkers  │ │
│  │   路由注册表     │  │   事件处理器     │  │   队列工作者     │ │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
│          ↓                      ↓                      ↓     │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
│  │   MessageTypes   │  │   EventTypes    │  │   QueueTypes    │ │
│  │   消息类型定义    │  │   事件类型定义   │  │   队列类型定义    │ │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
└─────────────────────────────────────────────────────────────┘

核心组件实现

1. 消息路由器
class MessageRouter:
    """消息路由器"""
    
    def __init__(self):
        self.routes = {}
        self.middleware_chain = []
        self.metrics = MessageMetrics()
        
    def register_route(self, message_type: str, handler: callable):
        """注册消息路由"""
        self.routes[message_type] = handler
        logger.info(f"注册路由: {message_type} -> {handler.__name__}")
        
    def add_middleware(self, middleware: callable):
        """添加中间件"""
        self.middleware_chain.append(middleware)
        
    async def route_message(self, message: Message) -> Response:
        """路由消息"""
        start_time = time.time()
        
        try:
            # 应用中间件
            processed_message = await self._apply_middleware(message)
            
            # 路由到处理器
            handler = self.routes.get(processed_message.type)
            if not handler:
                return Response(error="未找到处理器", status=404)
                
            # 执行处理器
            response = await handler(processed_message)
            
            # 记录指标
            duration = time.time() - start_time
            self.metrics.record_route_time(processed_message.type, duration)
            
            return response
            
        except Exception as e:
            logger.error(f"消息路由失败: {e}")
            self.metrics.record_route_error(processed_message.type, str(e))
            raise
            
    async def _apply_middleware(self, message: Message) -> Message:
        """应用中间件"""
        processed_message = message
        for middleware in self.middleware_chain:
            processed_message = await middleware(processed_message)
        return processed_message
2. 消息类型定义
class MessageType:
    """消息类型枚举"""
    
    # 用户消息
    USER_MESSAGE = "user_message"
    SYSTEM_MESSAGE = "system_message"
    AGENT_MESSAGE = "agent_message"
    
    # 业务消息
    TASK_CREATED = "task_created"
    TASK_UPDATED = "task_updated"
    TASK_COMPLETED = "task_completed"
    TASK_CANCELLED = "task_cancelled"
    
    # 审核消息
    REVIEW_REQUESTED = "review_requested"
    REVIEW_APPROVED = "review_approved"
    REVIEW_REJECTED = "review_rejected"
    
    # 事件消息
    AGENT_CREATED = "agent_created"
    AGENT_UPDATED = "agent_updated"
    AGENT_DELETED = "agent_deleted"
    
    def __init__(self):
        self._message_handlers = {}
        
    def register_handler(self, message_type: str, handler: callable):
        """注册消息处理器"""
        self._message_handlers[message_type] = handler
        
    async def handle_message(self, message: Message) -> Response:
        """处理消息"""
        handler = self._message_handlers.get(message.type)
        if not handler:
            raise ValueError(f"未找到消息处理器: {message.type}")
            
        return await handler(message)

事件驱动架构

1. 事件总线实现

class EventBus:
    """事件总线"""
    
    def __init__(self):
        self.subscribers = defaultdict(list)
        self.event_history = []
        self.max_history_size = 1000
        
    def subscribe(self, event_type: str, handler: callable):
        """订阅事件"""
        self.subscribers[event_type].append(handler)
        logger.info(f"订阅事件: {event_type}")
        
    def unsubscribe(self, event_type: str, handler: callable):
        """取消订阅"""
        if event_type in self.subscribers:
            self.subscribers[event_type].remove(handler)
            
    async def publish(self, event: Event):
        """发布事件"""
        start_time = time.time()
        
        # 记录事件历史
        self._record_event(event)
        
        # 通知订阅者
        subscribers = self.subscribers.get(event.type, [])
        for handler in subscribers:
            try:
                await handler(event)
            except Exception as e:
                logger.error(f"事件处理失败: {e}")
                
        # 记录指标
        duration = time.time() - start_time
        self._record_event_metric(event.type, duration)
        
    def _record_event(self, event: Event):
        """记录事件历史"""
        self.event_history.append({
            "type": event.type,
            "data": event.data,
            "timestamp": event.timestamp,
            "source": event.source
        })
        
        # 限制历史大小
        if len(self.event_history) > self.max_history_size:
            self.event_history.pop(0)
            
    def get_event_history(self, event_type: str = None, limit: int = 100):
        """获取事件历史"""
        events = self.event_history
        if event_type:
            events = [e for e in events if e["type"] == event_type]
        return events[-limit:]

2. 事件定义

class EventType:
    """事件类型枚举"""
    
    # 系统事件
    SYSTEM_STARTED = "system_started"
    SYSTEM_SHUTDOWN = "system_shutdown"
    CONFIG_UPDATED = "config_updated"
    
    # 用户事件
    USER_LOGIN = "user_login"
    USER_LOGOUT = "user_logout"
    USER_CREATED = "user_created"
    
    # Agent事件
    AGENT_CREATED = "agent_created"
    AGENT_UPDATED = "agent_updated"
    AGENT_DELETED = "agent_deleted"
    AGENT_ERROR = "agent_error"
    
    # 消息事件
    MESSAGE_SENT = "message_sent"
    MESSAGE_RECEIVED = "message_received"
    MESSAGE_PROCESSED = "message_processed"
    
    # 任务事件
    TASK_SCHEDULED = "task_scheduled"
    TASK_STARTED = "task_started"
    TASK_COMPLETED = "task_completed"
    TASK_FAILED = "task_failed"
    
    class Event:
        """事件基类"""
        
        def __init__(self, type: str, data: dict, source: str = "system"):
            self.type = type
            self.data = data
            self.source = source
            self.timestamp = datetime.now()
            self.id = str(uuid4())

消息队列管理

1. 队列管理器

class QueueManager:
    """队列管理器"""
    
    def __init__(self):
        self.queues = {}
        self.workers = {}
        self.metrics = QueueMetrics()
        
    def create_queue(self, queue_name: str, queue_type: str = "fifo"):
        """创建队列"""
        if queue_name not in self.queues:
            self.queues[queue_name] = MessageQueue(queue_name, queue_type)
            logger.info(f"创建队列: {queue_name}")
            
    def get_queue(self, queue_name: str) -> Optional[MessageQueue]:
        """获取队列"""
        return self.queues.get(queue_name)
        
    async def enqueue_message(self, queue_name: str, message: Message):
        """入队消息"""
        queue = self.get_queue(queue_name)
        if queue:
            await queue.enqueue(message)
            self.metrics.record_enqueue(queue_name)
        else:
            raise ValueError(f"队列不存在: {queue_name}")
            
    async def dequeue_message(self, queue_name: str, timeout: int = 5) -> Optional[Message]:
        """出队消息"""
        queue = self.get_queue(queue_name)
        if queue:
            message = await queue.dequeue(timeout)
            if message:
                self.metrics.record_dequeue(queue_name)
            return message
        return None

2. 消息队列实现

class MessageQueue:
    """消息队列"""
    
    def __init__(self, name: str, queue_type: str = "fifo"):
        self.name = name
        self.queue_type = queue_type
        self.queue = asyncio.Queue()
        self.priority_levels = ["low", "normal", "high", "critical"]
        
    async def enqueue(self, message: Message):
        """入队消息"""
        if self.queue_type == "priority":
            await self._enqueue_priority(message)
        else:
            await self.queue.put(message)
            
    async def dequeue(self, timeout: int = 5) -> Optional[Message]:
        """出队消息"""
        try:
            return await asyncio.wait_for(self.queue.get(), timeout)
        except asyncio.TimeoutError:
            return None
            
    async def _enqueue_priority(self, message: Message):
        """优先级入队"""
        priority = message.get("priority", "normal")
        if priority in self.priority_levels:
            # 根据优先级插入队列
            # 这里简化实现,实际应该根据优先级排序
            await self.queue.put(message)

消息处理中间件

1. 认证中间件

class AuthenticationMiddleware:
    """认证中间件"""
    
    def __init__(self, auth_service: AuthService):
        self.auth_service = auth_service
        
    async def __call__(self, message: Message) -> Message:
        """处理认证"""
        token = message.headers.get("Authorization")
        if not token:
            raise AuthenticationError("缺少认证令牌")
            
        # 验证令牌
        user = await self.auth_service.validate_token(token)
        if not user:
            raise AuthenticationError("无效的认证令牌")
            
        # 添加用户信息到消息
        message.user = user
        message.user_id = user.id
        
        return message

2. 日志中间件

class LoggingMiddleware:
    """日志中间件"""
    
    def __init__(self):
        self.logger = logging.getLogger("message_routing")
        
    async def __call__(self, message: Message) -> Message:
        """记录日志"""
        self.logger.info(f"处理消息: {message.type}, 来自: {message.source}")
        
        # 记录消息详情(不包括敏感信息)
        log_data = {
            "message_id": message.id,
            "type": message.type,
            "source": message.source,
            "timestamp": message.timestamp
        }
        self.logger.debug(f"消息详情: {log_data}")
        
        return message

3. 限流中间件

class RateLimitMiddleware:
    """限流中间件"""
    
    def __init__(self, rate_limiter: RateLimiter):
        self.rate_limiter = rate_limiter
        
    async def __call__(self, message: Message) -> Message:
        """检查限流"""
        user_id = message.user_id
        if user_id:
            if not await self.rate_limiter.check_rate_limit(user_id):
                raise RateLimitError("请求频率超限")
                
        return message

消息处理模式

1. 发布订阅模式

class PubSubManager:
    """发布订阅管理器"""
    
    def __init__(self):
        self.channels = defaultdict(list)
        
    def subscribe(self, channel: str, handler: callable):
        """订阅频道"""
        self.channels[channel].append(handler)
        
    async def publish(self, channel: str, message: Message):
        """发布消息到频道"""
        handlers = self.channels.get(channel, [])
        for handler in handlers:
            asyncio.create_task(handler(message))

2. 请求响应模式

class RequestResponseHandler:
    """请求响应处理器"""
    
    def __init__(self):
        self.pending_requests = {}
        self.response_timeout = 30
        
    async def send_request(self, request: Message) -> Message:
        """发送请求"""
        request_id = str(uuid4())
        request.id = request_id
        
        # 存储待处理请求
        future = asyncio.Future()
        self.pending_requests[request_id] = future
        
        # 发送请求
        await self._send_request(request)
        
        # 等待响应
        try:
            response = await asyncio.wait_for(future, self.response_timeout)
            return response
        except asyncio.TimeoutError:
            raise TimeoutError("请求超时")
            
    async def handle_response(self, response: Message):
        """处理响应"""
        request_id = response.request_id
        if request_id in self.pending_requests:
            future = self.pending_requests[request_id]
            future.set_result(response)
            del self.pending_requests[request_id]

监控与调优

1. 消息监控

class MessageMonitor:
    """消息监控器"""
    
    def __init__(self):
        self.metrics = MessageMetrics()
        self.alert_manager = AlertManager()
        
    async def monitor_message_flow(self):
        """监控消息流"""
        while True:
            try:
                # 检查消息队列状态
                await self._check_queue_status()
                
                # 检查处理器性能
                await self._check_handler_performance()
                
                # 检查错误率
                await self._check_error_rate()
                
                await asyncio.sleep(60)  # 每分钟检查一次
                
            except Exception as e:
                logger.error(f"监控失败: {e}")
                
    async def _check_queue_status(self):
        """检查队列状态"""
        for queue_name, queue in QueueManager.get_queues().items():
            if queue.size() > 1000:
                self.alert_manager.send_alert(
                    f"队列 {queue_name} 过大: {queue.size()}",
                    severity="warning"
                )

2. 性能调优

class PerformanceOptimizer:
    """性能优化器"""
    
    async def optimize_message_routing(self):
        """优化消息路由"""
        # 分析路由性能
        route_stats = await self._analyze_route_performance()
        
        # 识别瓶颈
        bottleneck_routes = self._identify_bottlenecks(route_stats)
        
        # 优化路由配置
        for route in bottleneck_routes:
            await self._optimize_route(route)
            
    async def _analyze_route_performance(self):
        """分析路由性能"""
        return MessageMetrics.get_route_performance()
        
    def _identify_bottlenecks(self, route_stats: dict) -> List[str]:
        """识别瓶颈路由"""
        # 根据处理时间、错误率等指标识别瓶颈
        bottleneck_routes = []
        for route, stats in route_stats.items():
            if stats["avg_time"] > 1.0 or stats["error_rate"] > 0.1:
                bottleneck_routes.append(route)
        return bottleneck_routes

总结

消息路由与事件驱动架构通过统一的消息路由器、事件总线、队列管理和中间件机制,实现了系统各组件间的高效通信。支持多种消息处理模式和监调优功能,确保了系统的高可用性和性能。下一篇文章将详细介绍流式消息处理与实时通信的实现。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/qq_20808209/article/details/171108743

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--