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



