sycommon-python-lib 0.1.46__py3-none-any.whl → 0.1.56b5__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service.py

@@ -1,7 +1,7 @@
 import asyncio
 import json
 from typing import (
-    Callable, Coroutine, Dict, List, Optional, Type, Union, Any, Set
+    Callable, Coroutine, Dict, List, Optional, Type, Union, Any
 )
 from pydantic import BaseModel
 from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
@@ -18,11 +18,11 @@ logger = SYLogger
 
 class RabbitMQService:
     """
-    RabbitMQ服务封装，管理多个客户端实例，基于连接池实现资源复用
-    适配细粒度锁设计的RabbitMQClient，确保线程安全+高可用
+    RabbitMQ服务封装，管理多个客户端实例（适配单通道连接池）
+    核心特性：基于单通道连接池复用资源，简化状态管理，依赖原生自动重连
     """
 
-    # 保存多个客户端实例
+    # 保存多个客户端实例（共享单通道，仅维护配置差异）
     _clients: Dict[str, RabbitMQClient] = {}
     # 保存消息处理器
     _message_handlers: Dict[str, Callable[[
@@ -37,8 +37,6 @@ class RabbitMQService:
     _consumer_events: Dict[str, asyncio.Event] = {}
     # 存储消费者标签
     _consumer_tags: Dict[str, ConsumerTag] = {}
-    # 跟踪已初始化的队列
-    _initialized_queues: Set[str] = set()
     # 异步锁，确保初始化安全
     _init_locks: Dict[str, asyncio.Lock] = {}
     # 标记是否有监听器和发送器
@@ -46,7 +44,7 @@ class RabbitMQService:
     _has_senders: bool = False
     # 消费启动超时设置
     CONSUMER_START_TIMEOUT = 30  # 30秒超时
-    # 连接池实例
+    # 连接池实例（单通道）
     _connection_pool: Optional[RabbitMQConnectionPool] = None
     # 服务关闭标记
     _is_shutdown: bool = False
@@ -56,11 +54,10 @@ class RabbitMQService:
     _connection_monitor_task: Optional[asyncio.Task] = None
     # 重连配置
     RECONNECT_INTERVAL = 15  # 重连基础间隔（秒）
-    MAX_RECONNECT_ATTEMPTS = 10  # 最大连续重连次数
 
     @classmethod
     def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
-        """初始化RabbitMQ服务（支持集群配置），同时创建连接池"""
+        """初始化RabbitMQ服务（支持集群配置），同时创建单通道连接池"""
         from sycommon.synacos.nacos_service import NacosService
 
         # 防止重复初始化
@@ -98,7 +95,7 @@ class RabbitMQService:
 
     @classmethod
     async def _init_connection_pool(cls):
-        """初始化连接池（异步操作，带重试）"""
+        """初始化单通道连接池（异步操作，带重试）"""
         if cls._connection_pool or not cls._config or cls._is_shutdown:
             return
 
@@ -112,7 +109,7 @@ class RabbitMQService:
 
             global_prefetch_count = cls._config.get('prefetch_count', 2)
 
-            # 创建连接池
+            # 创建单通道连接池（已移除channel_pool_size参数）
             cls._connection_pool = RabbitMQConnectionPool(
                 hosts=hosts_list,
                 port=cls._config.get('port', 5672),
@@ -121,11 +118,14 @@ class RabbitMQService:
                 virtualhost=cls._config.get('virtual-host', "/"),
                 app_name=cls._config.get("APP_NAME", ""),
                 prefetch_count=global_prefetch_count,
+                heartbeat=cls._config.get('heartbeat', 30),
+                connection_timeout=cls._config.get('connection_timeout', 30),
+                reconnect_interval=cls._config.get('reconnect_interval', 5),
             )
 
             # 初始化连接池
             await asyncio.wait_for(cls._connection_pool.init_pools(), timeout=30)
-            logger.info("RabbitMQ连接池初始化成功")
+            logger.info("RabbitMQ单通道连接池初始化成功")
 
         except Exception as e:
             logger.error(f"RabbitMQ连接池初始化失败: {str(e)}", exc_info=True)
@@ -136,7 +136,7 @@ class RabbitMQService:
 
     @classmethod
     async def _monitor_connections(cls):
-        """连接监控任务：定期检查所有客户端连接状态，自动重连"""
+        """连接监控任务：定期检查所有客户端连接状态，依赖连接池原生重连"""
         logger.info("RabbitMQ连接监控任务启动")
         while not cls._is_shutdown:
             try:
@@ -146,40 +146,25 @@ class RabbitMQService:
                 if not cls._connection_pool or not cls._connection_pool._initialized:
                     continue
 
-                # 检查所有客户端连接
-                # 使用list避免迭代中修改
+                # 检查连接池本身状态
+                pool_alive = await cls._connection_pool.is_alive
+                if not pool_alive:
+                    logger.error("RabbitMQ连接池已断开，等待原生自动重连")
+                    continue
+
+                # 检查所有客户端连接（单通道场景下，客户端状态依赖通道有效性）
                 for client_name, client in list(cls._clients.items()):
                     try:
-                        # 双重校验连接状态（客户端内部校验 + 连接池连接校验）
                         client_connected = await client.is_connected
-                        conn_connected = not (
-                            client._channel_conn and client._channel_conn.is_closed)
-
-                        if not client_connected or not conn_connected:
+                        if not client_connected:
                             logger.warning(
-                                f"客户端 '{client_name}' 连接异常 - 客户端状态: {client_connected}, "
-                                f"连接状态: {conn_connected}，触发自动重连"
-                            )
-
-                            # 重连前先清理无效资源
-                            await cls._clean_client_resources(client)
-
-                            # 执行重连（带重试）
-                            reconnect_success = await cls._reconnect_client(client_name, client)
-                            if reconnect_success:
-                                logger.info(f"客户端 '{client_name}' 重连成功")
-                            else:
-                                logger.error(f"客户端 '{client_name}' 重连失败，将继续监控")
-
+                                f"客户端 '{client_name}' 连接异常，触发重连")
+                            asyncio.create_task(
+                                cls._reconnect_client(client_name, client))
                     except Exception as e:
                         logger.error(
                             f"监控客户端 '{client_name}' 连接状态失败: {str(e)}", exc_info=True)
 
-                # 检查连接池状态（如果连接池已关闭，重新初始化）
-                if not await cls._connection_pool.is_alive:
-                    logger.error("RabbitMQ连接池已关闭，尝试重新初始化")
-                    asyncio.create_task(cls._init_connection_pool())
-
             except Exception as e:
                 logger.error("RabbitMQ连接监控任务异常", exc_info=True)
                 await asyncio.sleep(cls.RECONNECT_INTERVAL)  # 异常后延迟重启监控
@@ -188,19 +173,16 @@ class RabbitMQService:
 
     @classmethod
     async def _clean_client_resources(cls, client: RabbitMQClient):
-        """清理客户端无效资源（通道+连接）"""
+        """清理客户端无效资源（单通道场景下仅重置状态，无需归还通道）"""
         try:
-            if client._channel and client._channel_conn:
-                # 先停止消费（避免消费中释放资源）
-                if client._consumer_tag:
-                    await client.stop_consuming()
-                # 释放通道到连接池
-                await cls._connection_pool.release_channel(client._channel, client._channel_conn)
-                logger.debug("客户端无效资源释放成功")
+            # 先停止消费（避免消费中操作资源）
+            if client._consumer_tag:
+                await client.stop_consuming()
+            logger.debug("客户端无效资源清理完成（单通道无需归还）")
         except Exception as e:
             logger.warning(f"释放客户端无效资源失败: {str(e)}")
         finally:
-            # 强制重置客户端状态
+            # 强制重置客户端状态（通道由连接池自动恢复）
             client._channel = None
             client._channel_conn = None
             client._exchange = None
@@ -209,48 +191,38 @@ class RabbitMQService:
 
     @classmethod
     async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
-        """客户端重连（带重试机制）"""
-        # 重连冷却，避免任务堆积
-        cooldown = cls.RECONNECT_INTERVAL * 2
-        await asyncio.sleep(cooldown)
+        """客户端重连（依赖连接池原生重连，仅重建客户端资源）"""
+        if cls._is_shutdown or not await cls._connection_pool.is_alive:
+            return False
 
-        for attempt in range(cls.MAX_RECONNECT_ATTEMPTS):
-            try:
-                # 执行重连
-                await client.connect()
+        # 重连冷却
+        await asyncio.sleep(cls.RECONNECT_INTERVAL)
 
-                # 验证重连结果（双重校验）
-                if await client.is_connected and client._queue:
-                    # 如果是消费者，重新启动消费
-                    if client_name in cls._message_handlers:
-                        # 先停止旧的消费任务
-                        if client_name in cls._consumer_tasks:
-                            old_task = cls._consumer_tasks[client_name]
-                            if not old_task.done():
-                                old_task.cancel()
-                                try:
-                                    await asyncio.wait_for(old_task, timeout=5)
-                                except:
-                                    pass
-                        # 启动新的消费任务
-                        await cls.start_consumer(client_name)
-                    return True
-                else:
-                    logger.warning(
-                        f"客户端 '{client_name}' 重连尝试 {attempt+1} 失败：资源未完全初始化")
-            except Exception as e:
-                logger.error(
-                    f"客户端 '{client_name}' 重连尝试 {attempt+1} 失败: {str(e)}", exc_info=True)
+        try:
+            # 清理旧资源
+            await cls._clean_client_resources(client)
 
-            await asyncio.sleep(cls.RECONNECT_INTERVAL)
+            # 执行重连（客户端内部会从连接池获取新通道）
+            await client.connect()
 
-        if not cls._is_shutdown:
-            asyncio.create_task(cls._reconnect_client(client_name, client))
-        return False
+            # 验证重连结果
+            if await client.is_connected:
+                logger.info(f"客户端 '{client_name}' 重连成功")
+                # 如果是消费者，重新启动消费
+                if client_name in cls._message_handlers:
+                    await cls.start_consumer(client_name)
+                return True
+            else:
+                logger.warning(f"客户端 '{client_name}' 重连失败：资源未完全初始化")
+                return False
+        except Exception as e:
+            logger.error(f"客户端 '{client_name}' 重连失败: {str(e)}", exc_info=True)
+            # 重连失败后，由监控任务再次触发（避免死循环）
+            return False
 
     @classmethod
     async def _create_client(cls, queue_name: str, **kwargs) -> RabbitMQClient:
-        """创建客户端实例（适配新的RabbitMQClient API）"""
+        """创建客户端实例（适配单通道连接池的RabbitMQClient）"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
 
@@ -285,7 +257,7 @@ class RabbitMQService:
             f"允许创建: {create_if_not_exists}"
         )
 
-        # 创建客户端实例（适配新的RabbitMQClient参数）
+        # 创建客户端实例（适配精简版RabbitMQClient参数）
         client = RabbitMQClient(
             connection_pool=cls._connection_pool,
             exchange_name=cls._config.get(
@@ -301,15 +273,9 @@ class RabbitMQService:
             prefetch_count=kwargs.get('prefetch_count', 2),
         )
 
-        # 连接客户端
+        # 连接客户端（单通道场景下快速连接）
         await client.connect()
 
-        # 监听器客户端连接后延迟1秒，确保消费状态就绪（仅首次启动）
-        if not is_sender and create_if_not_exists:
-            logger.info(
-                f"监听器客户端 '{processed_queue_name}' 连接成功，延迟1秒启动消费（解决启动时序问题）")
-            await asyncio.sleep(1)
-
         return client
 
     @classmethod
@@ -317,7 +283,7 @@ class RabbitMQService:
         cls,
         client_name: str = "default", **kwargs
     ) -> RabbitMQClient:
-        """获取或创建RabbitMQ客户端（基于连接池，线程安全）"""
+        """获取或创建RabbitMQ客户端（单通道池，线程安全）"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
 
@@ -353,7 +319,7 @@ class RabbitMQService:
                         await client.connect()
                     return client
                 else:
-                    logger.info(f"客户端 '{client_name}' 连接已关闭，重新连接")
+                    logger.info(f"客户端 '{client_name}' 连接已断开，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
                     await client.connect()
@@ -375,16 +341,9 @@ class RabbitMQService:
                 cls._clients[client_name] = client
                 return client
 
-            # 监听器逻辑
+            # 监听器逻辑（单通道支持多队列声明，无需跟踪已初始化队列）
             kwargs['create_if_not_exists'] = True
 
-            # 检查队列是否已初始化
-            if initial_queue_name in cls._initialized_queues:
-                logger.info(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
-                client = await cls._create_client(initial_queue_name, **kwargs)
-                cls._clients[client_name] = client
-                return client
-
             # 创建并连接客户端
             client = await cls._create_client(
                 initial_queue_name,
@@ -400,17 +359,12 @@ class RabbitMQService:
                 if not client._queue:
                     raise Exception(f"无法创建队列 '{initial_queue_name}'")
 
-            # 记录已初始化的队列
-            final_queue_name = client.queue_name
-            if final_queue_name:
-                cls._initialized_queues.add(final_queue_name)
-
             cls._clients[client_name] = client
             return client
 
     @classmethod
     async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, **kwargs) -> None:
-        """设置消息发送器（适配新客户端）"""
+        """设置消息发送器（适配单通道客户端）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法设置发送器")
             return
@@ -475,7 +429,7 @@ class RabbitMQService:
 
     @classmethod
     async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
-        """设置消息监听器（适配新客户端）"""
+        """设置消息监听器（适配单通道客户端）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法设置监听器")
             return
@@ -544,7 +498,7 @@ class RabbitMQService:
         queue_name: str,
         handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], **kwargs
     ) -> None:
-        """添加消息监听器（线程安全）"""
+        """添加消息监听器（线程安全，单通道场景）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法添加监听器")
             return
@@ -569,7 +523,7 @@ class RabbitMQService:
 
     @classmethod
     async def start_all_consumers(cls) -> None:
-        """启动所有已注册的消费者（线程安全）"""
+        """启动所有已注册的消费者（单通道场景，避免阻塞）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法启动消费者")
             return
@@ -579,7 +533,7 @@ class RabbitMQService:
 
     @classmethod
     async def start_consumer(cls, client_name: str) -> None:
-        """启动指定客户端的消费者"""
+        """启动指定客户端的消费者（单通道消费，需确保回调非阻塞）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法启动消费者")
             return
@@ -622,20 +576,15 @@ class RabbitMQService:
         if cls._is_shutdown:
             return
 
-        # 监听器启动消费前额外延迟1秒
-        if cls._has_listeners and not client_name.startswith("sender-"):
-            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪")
-            await asyncio.sleep(1)
-
         # 创建停止事件
         stop_event = asyncio.Event()
         cls._consumer_events[client_name] = stop_event
 
-        # 定义消费任务
+        # 定义消费任务（单通道场景下，消费回调需非阻塞）
         async def consume_task():
             try:
                 # 启动消费，带重试机制
-                max_attempts = 5
+                max_attempts = 3
                 attempt = 0
                 consumer_tag = None
 
@@ -671,7 +620,9 @@ class RabbitMQService:
                 # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
                 logger.info(
-                    f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
+                    f"消费者 '{client_name}' 开始消费（单通道），tag: {consumer_tag}，"
+                    f"注意：消费回调需非阻塞，避免影响其他客户端"
+                )
 
                 # 等待停止事件
                 await stop_event.wait()
@@ -731,7 +682,7 @@ class RabbitMQService:
 
     @classmethod
     async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
-        """获取发送客户端"""
+        """获取发送客户端（适配单通道池）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法获取发送器")
             return None
@@ -781,7 +732,7 @@ class RabbitMQService:
         data: Union[BaseModel, str, Dict[str, Any], None],
         queue_name: str, **kwargs
     ) -> None:
-        """发送消息到指定队列"""
+        """发送消息到指定队列（单通道场景下快速发送）"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法发送消息")
 
@@ -853,7 +804,7 @@ class RabbitMQService:
                 ).model_dump_json()
             }
 
-            # 发送消息
+            # 发送消息（单通道场景下依赖原生异步确认）
             await sender.publish(
                 message_body=mq_message.model_dump_json(),
                 headers=mq_header,
@@ -866,7 +817,7 @@ class RabbitMQService:
 
     @classmethod
     async def shutdown(cls, timeout: float = 15.0) -> None:
-        """优雅关闭所有资源（线程安全）"""
+        """优雅关闭所有资源（单通道场景下简化关闭流程）"""
         async with cls._shutdown_lock:
             if cls._is_shutdown:
                 logger.info("RabbitMQService已关闭，无需重复操作")
@@ -898,18 +849,18 @@ class RabbitMQService:
                     except Exception as e:
                         logger.error(f"关闭消费者 '{client_name}' 失败: {str(e)}")
 
-            # 3. 关闭所有客户端
+            # 3. 关闭所有客户端（单通道场景下客户端关闭仅清理状态）
             for client in cls._clients.values():
                 try:
                     await client.close()
                 except Exception as e:
                     logger.error(f"关闭客户端失败: {str(e)}")
 
-            # 4. 关闭连接池
+            # 4. 关闭连接池（单通道池关闭会释放所有资源）
             if cls._connection_pool and cls._connection_pool._initialized:
                 try:
                     await cls._connection_pool.close()
-                    logger.info("RabbitMQ连接池已关闭")
+                    logger.info("RabbitMQ单通道连接池已关闭")
                 except Exception as e:
                     logger.error(f"关闭连接池失败: {str(e)}")
 
@@ -919,7 +870,6 @@ class RabbitMQService:
             cls._consumer_tasks.clear()
             cls._consumer_events.clear()
             cls._consumer_tags.clear()
-            cls._initialized_queues.clear()
             cls._sender_client_names.clear()
             cls._init_locks.clear()
             cls._config = None