sycommon-python-lib 0.1.16__py3-none-any.whl → 0.1.56b1__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service.py

@@ -1,7 +1,7 @@
 import asyncio
-import logging
+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
@@ -11,21 +11,22 @@ from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.models.sso_user import SsoUser
 from sycommon.logging.kafka_log import SYLogger
-from .rabbitmq_client import RabbitMQClient
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient, RabbitMQConnectionPool
 
 logger = SYLogger
 
 
 class RabbitMQService:
     """
-    RabbitMQ服务封装，管理多个客户端实例，提供发送和接收消息的高级接口
-    负责客户端的创建、配置、生命周期管理和错误处理
+    RabbitMQ服务封装，管理多个客户端实例（适配单通道连接池）
+    核心特性：基于单通道连接池复用资源，简化状态管理，依赖原生自动重连
     """
 
-    # 保存多个客户端实例
+    # 保存多个客户端实例（共享单通道，仅维护配置差异）
     _clients: Dict[str, RabbitMQClient] = {}
     # 保存消息处理器
-    _message_handlers: Dict[str, Callable] = {}
+    _message_handlers: Dict[str, Callable[[
+        MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = {}
     # 保存消费者任务
     _consumer_tasks: Dict[str, asyncio.Task] = {}
     # 保存配置信息
@@ -36,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] = {}
     # 标记是否有监听器和发送器
@@ -45,14 +44,27 @@ class RabbitMQService:
     _has_senders: bool = False
     # 消费启动超时设置
     CONSUMER_START_TIMEOUT = 30  # 30秒超时
+    # 连接池实例（单通道）
+    _connection_pool: Optional[RabbitMQConnectionPool] = None
+    # 服务关闭标记
+    _is_shutdown: bool = False
+    # 服务关闭锁
+    _shutdown_lock = asyncio.Lock()
+    # 连接状态监控任务
+    _connection_monitor_task: Optional[asyncio.Task] = None
+    # 重连配置
+    RECONNECT_INTERVAL = 15  # 重连基础间隔（秒）
 
     @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
 
+        # 防止重复初始化
+        if cls._config:
+            logger.warning("RabbitMQService已初始化，无需重复调用")
+            return cls
+
         # 获取MQ配置
         cls._config = NacosService(config).share_configs.get(
             "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
@@ -63,24 +75,169 @@ class RabbitMQService:
             f"RabbitMQ服务初始化 - 集群节点: {cls._config.get('host')}, "
             f"端口: {cls._config.get('port')}, "
             f"虚拟主机: {cls._config.get('virtual-host')}, "
-            f"应用名: {cls._config.get('APP_NAME')}"
+            f"应用名: {cls._config.get('APP_NAME')}, "
+            f"心跳: {cls._config.get('heartbeat', 30)}s"
         )
 
         # 保存发送器和监听器存在状态
         cls._has_listeners = has_listeners
         cls._has_senders = has_senders
+        cls._is_shutdown = False
+
+        # 初始化连接池（在单独的异步方法中启动）
+        asyncio.create_task(cls._init_connection_pool())
+
+        # 启动连接监控任务（监听连接状态，自动重连）
+        cls._connection_monitor_task = asyncio.create_task(
+            cls._monitor_connections())
 
         return cls
 
     @classmethod
-    async def _create_client(cls, mq_config: dict, queue_name: str, **kwargs) -> RabbitMQClient:
-        """
-        创建RabbitMQ客户端实例（支持集群节点列表）
-        """
+    async def _init_connection_pool(cls):
+        """初始化单通道连接池（异步操作，带重试）"""
+        if cls._connection_pool or not cls._config or cls._is_shutdown:
+            return
+
+        try:
+            # 解析集群节点
+            hosts_str = cls._config.get('host', "")
+            hosts_list = [host.strip()
+                          for host in hosts_str.split(',') if host.strip()]
+            if not hosts_list:
+                raise ValueError("RabbitMQ集群配置为空，请检查host参数")
+
+            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),
+                username=cls._config.get('username', ""),
+                password=cls._config.get('password', ""),
+                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单通道连接池初始化成功")
+
+        except Exception as e:
+            logger.error(f"RabbitMQ连接池初始化失败: {str(e)}", exc_info=True)
+            # 连接池初始化失败时重试（未关闭状态下）
+            if not cls._is_shutdown:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+                asyncio.create_task(cls._init_connection_pool())
+
+    @classmethod
+    async def _monitor_connections(cls):
+        """连接监控任务：定期检查所有客户端连接状态，依赖连接池原生重连"""
+        logger.info("RabbitMQ连接监控任务启动")
+        while not cls._is_shutdown:
+            try:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)  # 固定15秒间隔
+
+                # 跳过未初始化的连接池
+                if not cls._connection_pool or not cls._connection_pool._initialized:
+                    continue
+
+                # 检查连接池本身状态
+                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
+                        if not client_connected:
+                            logger.warning(
+                                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)
+
+            except Exception as e:
+                logger.error("RabbitMQ连接监控任务异常", exc_info=True)
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)  # 异常后延迟重启监控
+
+        logger.info("RabbitMQ连接监控任务停止")
+
+    @classmethod
+    async def _clean_client_resources(cls, client: RabbitMQClient):
+        """清理客户端无效资源（单通道场景下仅重置状态，无需归还通道）"""
+        try:
+            # 先停止消费（避免消费中操作资源）
+            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
+            client._queue = None
+            client._consumer_tag = None
+
+    @classmethod
+    async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
+        """客户端重连（依赖连接池原生重连，仅重建客户端资源）"""
+        if cls._is_shutdown or not await cls._connection_pool.is_alive:
+            return False
+
+        # 重连冷却
+        await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        try:
+            # 清理旧资源
+            await cls._clean_client_resources(client)
+
+            # 执行重连（客户端内部会从连接池获取新通道）
+            await client.connect()
+
+            # 验证重连结果
+            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）"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
+
+        if not cls._connection_pool or not cls._connection_pool._initialized:
+            # 等待连接池初始化
+            start_time = asyncio.get_event_loop().time()
+            while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
+                if asyncio.get_event_loop().time() - start_time > 30:
+                    raise TimeoutError("等待连接池初始化超时")
+                await asyncio.sleep(1)
+            if cls._is_shutdown:
+                raise RuntimeError("服务关闭中，取消创建客户端")
+
         app_name = kwargs.get('app_name', cls._config.get(
             "APP_NAME", "")) if cls._config else ""
-
-        # 确定是否为发送器
         is_sender = not cls._has_listeners
 
         # 根据组件类型决定是否允许创建队列
@@ -95,25 +252,15 @@ class RabbitMQService:
             else:
                 logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
 
-        logger.debug(
+        logger.info(
             f"创建客户端 - 队列: {processed_queue_name}, 发送器: {is_sender}, "
             f"允许创建: {create_if_not_exists}"
         )
 
-        # 将逗号分隔的host字符串拆分为集群节点列表
-        hosts_str = mq_config.get('host', "")
-        hosts_list = [host.strip()
-                      for host in hosts_str.split(',') if host.strip()]
-        if not hosts_list:
-            raise ValueError("RabbitMQ集群配置为空，请检查host参数")
-
-        return RabbitMQClient(
-            hosts=hosts_list,
-            port=mq_config.get('port', 5672),
-            username=mq_config.get('username', ""),
-            password=mq_config.get('password', ""),
-            virtualhost=mq_config.get('virtual-host', "/"),
-            exchange_name=mq_config.get(
+        # 创建客户端实例（适配精简版RabbitMQClient参数）
+        client = RabbitMQClient(
+            connection_pool=cls._connection_pool,
+            exchange_name=cls._config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
             queue_name=processed_queue_name,
@@ -123,33 +270,36 @@ class RabbitMQService:
             auto_delete=kwargs.get('auto_delete', False),
             auto_parse_json=kwargs.get('auto_parse_json', True),
             create_if_not_exists=create_if_not_exists,
-            connection_timeout=kwargs.get('connection_timeout', 10),
-            rpc_timeout=kwargs.get('rpc_timeout', 5),
-            app_name=app_name,
-            reconnection_delay=kwargs.get('reconnection_delay', 1),
-            max_reconnection_attempts=kwargs.get(
-                'max_reconnection_attempts', 5),
-            heartbeat=kwargs.get('heartbeat', 10),
             prefetch_count=kwargs.get('prefetch_count', 2),
-            consumption_stall_threshold=kwargs.get(
-                'consumption_stall_threshold', 10)
         )
 
+        # 连接客户端（单通道场景下快速连接）
+        await client.connect()
+
+        return client
+
     @classmethod
     async def get_client(
         cls,
-        client_name: str = "default", ** kwargs
+        client_name: str = "default", **kwargs
     ) -> RabbitMQClient:
-        """
-        获取或创建RabbitMQ客户端
+        """获取或创建RabbitMQ客户端（单通道池，线程安全）"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
 
-        :param client_name: 客户端名称
-        :param kwargs: 客户端参数
-        :return: RabbitMQClient实例
-        """
         if not cls._config:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
+        # 等待连接池就绪
+        if not cls._connection_pool or not cls._connection_pool._initialized:
+            start_time = asyncio.get_event_loop().time()
+            while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
+                if asyncio.get_event_loop().time() - start_time > 30:
+                    raise TimeoutError("等待连接池初始化超时")
+                await asyncio.sleep(1)
+            if cls._is_shutdown:
+                raise RuntimeError("服务关闭中，取消获取客户端")
+
         # 确保锁存在
         if client_name not in cls._init_locks:
             cls._init_locks[client_name] = asyncio.Lock()
@@ -161,18 +311,18 @@ class RabbitMQService:
                 is_sender = not cls._has_listeners or (
                     not kwargs.get('create_if_not_exists', True))
 
-                if client.is_connected:
+                if await client.is_connected:
                     # 如果是监听器但队列未初始化，重新连接
-                    if not is_sender and not client.queue:
-                        logger.debug(f"客户端 '{client_name}' 队列未初始化，重新连接")
+                    if not is_sender and not client._queue:
+                        logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
-                        await client.connect(force_reconnect=True, declare_queue=True)
+                        await client.connect()
                     return client
                 else:
-                    logger.debug(f"客户端 '{client_name}' 连接已关闭，重新连接")
+                    logger.info(f"客户端 '{client_name}' 连接已断开，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
-                    await client.connect(declare_queue=not is_sender)
+                    await client.connect()
                     return client
 
             # 创建新客户端
@@ -184,66 +334,42 @@ class RabbitMQService:
             if is_sender:
                 kwargs['create_if_not_exists'] = False
                 client = await cls._create_client(
-                    cls._config,
                     initial_queue_name,
                     app_name=cls._config.get("APP_NAME", ""),
                     **kwargs
                 )
-                await client.connect(declare_queue=False)
                 cls._clients[client_name] = client
                 return client
 
-            # 监听器逻辑
+            # 监听器逻辑（单通道支持多队列声明，无需跟踪已初始化队列）
             kwargs['create_if_not_exists'] = True
 
-            # 检查队列是否已初始化
-            if initial_queue_name in cls._initialized_queues:
-                logger.debug(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
-                client = await cls._create_client(
-                    cls._config,
-                    initial_queue_name, ** kwargs
-                )
-                await client.connect(declare_queue=True)
-                cls._clients[client_name] = client
-                return client
-
             # 创建并连接客户端
             client = await cls._create_client(
-                cls._config,
                 initial_queue_name,
                 app_name=cls._config.get("APP_NAME", ""),
                 **kwargs
             )
 
-            client.create_if_not_exists = True
-            await client.connect(declare_queue=True)
-
             # 验证队列是否创建成功
-            if not client.queue:
+            if not client._queue:
                 logger.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
                 client.create_if_not_exists = True
-                await client.connect(force_reconnect=True, declare_queue=True)
-                if not client.queue:
+                await client.connect()
+                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) -> None:
-        """
-        设置消息发送器
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, **kwargs) -> None:
+        """设置消息发送器（适配单通道客户端）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法设置发送器")
+            return
 
-        :param senders: 发送器配置列表
-        :param has_listeners: 是否同时存在监听器
-        """
         cls._has_senders = True
-        # 保存监听器存在状态
         cls._has_listeners = has_listeners
         logger.info(f"开始设置 {len(senders)} 个消息发送器")
 
@@ -252,6 +378,7 @@ class RabbitMQService:
                 if not sender_config.queue_name:
                     raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
 
+                prefetch_count = sender_config.prefetch_count
                 queue_name = sender_config.queue_name
                 app_name = cls._config.get(
                     "APP_NAME", "") if cls._config else ""
@@ -260,18 +387,18 @@ class RabbitMQService:
                 normalized_name = queue_name
                 if app_name and normalized_name.endswith(f".{app_name}"):
                     normalized_name = normalized_name[:-len(f".{app_name}")]
-                    logger.debug(f"发送器队列名称移除app-name后缀: {normalized_name}")
+                    logger.info(f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                 # 检查是否已初始化
                 if normalized_name in cls._sender_client_names:
-                    logger.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
+                    logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
                     continue
 
                 # 获取或创建客户端
                 if normalized_name in cls._clients:
                     client = cls._clients[normalized_name]
-                    if not client.is_connected:
-                        await client.connect(declare_queue=False)
+                    if not await client.is_connected:
+                        await client.connect()
                 else:
                     client = await cls.get_client(
                         client_name=normalized_name,
@@ -280,7 +407,9 @@ class RabbitMQService:
                         auto_delete=sender_config.auto_delete,
                         auto_parse_json=sender_config.auto_parse_json,
                         queue_name=queue_name,
-                        create_if_not_exists=False
+                        create_if_not_exists=False,
+                        prefetch_count=prefetch_count,
+                        **kwargs
                     )
 
                 # 记录客户端
@@ -299,15 +428,13 @@ class RabbitMQService:
         logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False) -> None:
-        """
-        设置消息监听器
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
+        """设置消息监听器（适配单通道客户端）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法设置监听器")
+            return
 
-        :param listeners: 监听器配置列表
-        :param has_senders: 是否同时存在发送器
-        """
         cls._has_listeners = True
-        # 保存发送器存在状态
         cls._has_senders = has_senders
         logger.info(f"开始设置 {len(listeners)} 个消息监听器")
 
@@ -316,9 +443,11 @@ class RabbitMQService:
                 # 转换配置并强制设置create_if_not_exists为True
                 listener_dict = listener_config.model_dump()
                 listener_dict['create_if_not_exists'] = True
+                listener_dict['prefetch_count'] = listener_config.prefetch_count
                 queue_name = listener_dict['queue_name']
 
-                logger.info(f"设置监听器 {idx+1}/{len(listeners)}: {queue_name}")
+                logger.info(
+                    f"设置监听器 {idx+1}/{len(listeners)}: {queue_name} (prefetch_count: {listener_config.prefetch_count})")
 
                 # 添加监听器
                 await cls.add_listener(**listener_dict)
@@ -337,18 +466,14 @@ class RabbitMQService:
 
     @classmethod
     async def _verify_consumers_started(cls, timeout: int = 30) -> None:
-        """
-        验证消费者是否成功启动
-
-        :param timeout: 超时时间(秒)
-        """
+        """验证消费者是否成功启动"""
         start_time = asyncio.get_event_loop().time()
         required_clients = list(cls._message_handlers.keys())
         running_clients = []
 
-        # 等待所有消费者启动或超时
         while len(running_clients) < len(required_clients) and \
-                (asyncio.get_event_loop().time() - start_time) < timeout:
+                (asyncio.get_event_loop().time() - start_time) < timeout and \
+                not cls._is_shutdown:
 
             running_clients = [
                 name for name, task in cls._consumer_tasks.items()
@@ -357,14 +482,12 @@ class RabbitMQService:
 
             logger.info(
                 f"消费者启动验证: {len(running_clients)}/{len(required_clients)} 已启动")
-            await asyncio.sleep(2)
+            await asyncio.sleep(1)
 
-        # 检查未成功启动的消费者
         failed_clients = [
-            name for name in required_clients if name not in running_clients]
+            name for name in required_clients if name not in running_clients and not cls._is_shutdown]
         if failed_clients:
             logger.error(f"以下消费者启动失败: {', '.join(failed_clients)}")
-            # 尝试重新启动失败的消费者
             for client_name in failed_clients:
                 logger.info(f"尝试重新启动消费者: {client_name}")
                 asyncio.create_task(cls.start_consumer(client_name))
@@ -373,20 +496,18 @@ class RabbitMQService:
     async def add_listener(
         cls,
         queue_name: str,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], ** kwargs
+        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], **kwargs
     ) -> None:
-        """
-        添加消息监听器
+        """添加消息监听器（线程安全，单通道场景）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法添加监听器")
+            return
 
-        :param queue_name: 队列名称
-        :param handler: 消息处理函数
-        :param kwargs: 其他参数
-        """
         if not cls._config:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
         if queue_name in cls._message_handlers:
-            logger.debug(f"监听器 '{queue_name}' 已存在，跳过重复添加")
+            logger.info(f"监听器 '{queue_name}' 已存在，跳过重复添加")
             return
 
         # 创建并初始化客户端
@@ -402,21 +523,35 @@ class RabbitMQService:
 
     @classmethod
     async def start_all_consumers(cls) -> None:
-        """启动所有已注册的消费者"""
+        """启动所有已注册的消费者（单通道场景，避免阻塞）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法启动消费者")
+            return
+
         for client_name in cls._message_handlers:
             await cls.start_consumer(client_name)
 
     @classmethod
     async def start_consumer(cls, client_name: str) -> None:
-        """
-        启动指定客户端的消费者
-
-        :param client_name: 客户端名称
-        """
-        if client_name in cls._consumer_tasks and not cls._consumer_tasks[client_name].done():
-            logger.debug(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+        """启动指定客户端的消费者（单通道消费，需确保回调非阻塞）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法启动消费者")
             return
 
+        # 检查任务状态，避免重复创建
+        if client_name in cls._consumer_tasks:
+            existing_task = cls._consumer_tasks[client_name]
+            if not existing_task.done():
+                # 检查任务是否处于异常状态，仅在异常时重启
+                if existing_task.exception() is not None:
+                    logger.info(f"消费者 '{client_name}' 任务异常，重启")
+                    existing_task.cancel()
+                else:
+                    logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+                    return
+            else:
+                logger.info(f"消费者 '{client_name}' 任务已完成，重新启动")
+
         if client_name not in cls._clients:
             raise ValueError(f"RabbitMQ客户端 '{client_name}' 未初始化")
 
@@ -428,31 +563,44 @@ class RabbitMQService:
             handler = cls.default_message_handler
 
         # 设置消息处理器
-        client.set_message_handler(handler)
+        await client.set_message_handler(handler)
 
         # 确保客户端已连接
         start_time = asyncio.get_event_loop().time()
-        while not client.is_connected:
+        while not await client.is_connected and not cls._is_shutdown:
             if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
                 raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
 
-            logger.debug(f"等待客户端 '{client_name}' 连接就绪...")
+            logger.info(f"等待客户端 '{client_name}' 连接就绪...")
             await asyncio.sleep(1)
+        if cls._is_shutdown:
+            return
 
         # 创建停止事件
         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
 
-                while attempt < max_attempts and not stop_event.is_set():
+                while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
                     try:
+                        # 启动消费前再次校验连接和队列状态
+                        if not await client.is_connected:
+                            logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
+                            await client.connect()
+
+                        # 确保队列和处理器已就绪
+                        if not client._queue:
+                            raise Exception("队列未初始化完成")
+                        if not client._message_handler:
+                            raise Exception("消息处理器未设置")
+
                         consumer_tag = await client.start_consuming()
                         if consumer_tag:
                             break
@@ -463,12 +611,18 @@ class RabbitMQService:
                         if attempt < max_attempts:
                             await asyncio.sleep(2)
 
+                if cls._is_shutdown:
+                    return
+
                 if not consumer_tag:
                     raise Exception(f"经过 {max_attempts} 次尝试仍无法启动消费者")
 
                 # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
-                logger.info(f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
+                logger.info(
+                    f"消费者 '{client_name}' 开始消费（单通道），tag: {consumer_tag}，"
+                    f"注意：消费回调需非阻塞，避免影响其他客户端"
+                )
 
                 # 等待停止事件
                 await stop_event.wait()
@@ -480,8 +634,9 @@ class RabbitMQService:
                 logger.error(
                     f"消费者 '{client_name}' 错误: {str(e)}", exc_info=True)
                 # 非主动停止时尝试重启
-                if not stop_event.is_set():
+                if not stop_event.is_set() and not cls._is_shutdown:
                     logger.info(f"尝试重启消费者 '{client_name}'")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
                     asyncio.create_task(cls.start_consumer(client_name))
             finally:
                 # 清理资源
@@ -510,8 +665,7 @@ class RabbitMQService:
                     t.result()
             except Exception as e:
                 logger.error(f"消费者任务 '{client_name}' 异常结束: {str(e)}")
-                # 任务异常时自动重启（如果服务未关闭）
-                if client_name in cls._message_handlers:  # 检查处理器是否仍存在
+                if client_name in cls._message_handlers and not cls._is_shutdown:
                     asyncio.create_task(cls.start_consumer(client_name))
 
         task.add_done_callback(task_done_callback)
@@ -527,57 +681,93 @@ class RabbitMQService:
         logger.info("===================\n")
 
     @classmethod
-    def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
-        """
-        获取发送客户端
+    async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
+        """获取发送客户端（适配单通道池）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法获取发送器")
+            return None
 
-        :param queue_name: 队列名称
-        :return: RabbitMQClient实例或None
-        """
         if not queue_name:
             logger.warning("发送器名称不能为空")
             return None
 
         # 检查是否在已注册的发送器中
         if queue_name in cls._sender_client_names and queue_name in cls._clients:
-            return cls._clients[queue_name]
+            client = cls._clients[queue_name]
+            if await client.is_connected:
+                return client
+            else:
+                logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
+                try:
+                    await client.connect()
+                    if await client.is_connected:
+                        return client
+                except Exception as e:
+                    logger.error(f"发送器 '{queue_name}' 重连失败: {str(e)}")
+            return None
 
         # 检查是否带有app-name后缀
         app_name = cls._config.get("APP_NAME", "") if cls._config else ""
-        if app_name and f"{queue_name}.{app_name}" in cls._sender_client_names:
-            return cls._clients.get(f"{queue_name}.{app_name}")
+        if app_name:
+            suffixed_name = f"{queue_name}.{app_name}"
+            if suffixed_name in cls._sender_client_names and suffixed_name in cls._clients:
+                client = cls._clients[suffixed_name]
+                if await client.is_connected:
+                    return client
+                else:
+                    logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
+                    try:
+                        await client.connect()
+                        if await client.is_connected:
+                            return client
+                    except Exception as e:
+                        logger.error(f"发送器 '{suffixed_name}' 重连失败: {str(e)}")
 
-        logger.debug(f"未找到发送器 '{queue_name}'")
+        logger.info(f"未找到可用的发送器 '{queue_name}'")
         return None
 
     @classmethod
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: str, ** kwargs
+        queue_name: str, **kwargs
     ) -> None:
-        """
-        发送消息到指定队列
+        """发送消息到指定队列（单通道场景下快速发送）"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法发送消息")
 
-        :param data: 消息数据
-        :param queue_name: 队列名称
-        :param kwargs: 其他参数
-        """
         # 获取发送客户端
-        sender = cls.get_sender(queue_name)
+        sender = await cls.get_sender(queue_name)
         if not sender:
             error_msg = f"未找到可用的RabbitMQ发送器 (queue_name: {queue_name})"
             logger.error(error_msg)
             raise ValueError(error_msg)
 
         # 确保连接有效
-        if not sender.is_connected:
+        if not await sender.is_connected:
             logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
-            try:
-                await sender.connect(force_reconnect=True)
-            except Exception as e:
-                logger.error(f"发送器 '{queue_name}' 重新连接失败: {str(e)}")
-                raise
+            max_retry = 3
+            retry_count = 0
+            last_exception = None
+
+            while retry_count < max_retry and not cls._is_shutdown:
+                try:
+                    await sender.connect()
+                    if await sender.is_connected:
+                        logger.info(
+                            f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
+                        break
+                except Exception as e:
+                    last_exception = e
+                    retry_count += 1
+                    logger.warning(
+                        f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+            if retry_count >= max_retry and not await sender.is_connected:
+                error_msg = f"发送器 '{queue_name}' 经过 {max_retry} 次重连仍失败"
+                logger.error(f"{error_msg}: {str(last_exception)}")
+                raise Exception(error_msg) from last_exception
 
         try:
             # 处理消息数据
@@ -587,19 +777,18 @@ class RabbitMQService:
             elif isinstance(data, BaseModel):
                 msg_content = data.model_dump_json()
             elif isinstance(data, dict):
-                import json
-                msg_content = json.dumps(data)
+                msg_content = json.dumps(data, ensure_ascii=False)
 
             # 创建标准消息模型
             mq_message = MQMsgModel(
                 topicCode=queue_name.split('.')[0] if queue_name else "",
                 msg=msg_content,
                 correlationDataId=kwargs.get(
-                    'correlationDataId', SYLogger.get_trace_id()),
+                    'correlationDataId', logger.get_trace_id()),
                 groupId=kwargs.get('groupId', ''),
                 dataKey=kwargs.get('dataKey', ""),
                 manualFlag=kwargs.get('manualFlag', False),
-                traceId=SYLogger.get_trace_id()
+                traceId=logger.get_trace_id()
             )
 
             # 构建消息头
@@ -611,11 +800,11 @@ class RabbitMQService:
                     user_name="SYSTEM",
                     request_path="",
                     req_type="SYSTEM",
-                    trace_id=SYLogger.get_trace_id(),
+                    trace_id=logger.get_trace_id(),
                 ).model_dump_json()
             }
 
-            # 发送消息
+            # 发送消息（单通道场景下依赖原生异步确认）
             await sender.publish(
                 message_body=mq_message.model_dump_json(),
                 headers=mq_header,
@@ -627,69 +816,62 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def shutdown(cls, timeout: float = 10.0) -> None:
-        """
-        优雅关闭所有资源
-
-        :param timeout: 超时时间(秒)
-        """
-        start_time = asyncio.get_event_loop().time()
-        logger.info("开始关闭RabbitMQ服务...")
-
-        # 发送停止信号给所有消费者
-        for client_name, event in cls._consumer_events.items():
-            event.set()
-            logger.info(f"已向消费者 '{client_name}' 发送退出信号")
-
-        # 等待消费者任务完成
-        remaining_time = max(
-            0.0, timeout - (asyncio.get_event_loop().time() - start_time))
-        if remaining_time > 0 and cls._consumer_tasks:
-            try:
-                # 等待所有消费者任务完成或超时
-                done, pending = await asyncio.wait(
-                    list(cls._consumer_tasks.values()),
-                    timeout=remaining_time,
-                    return_when=asyncio.ALL_COMPLETED
-                )
-
-                # 处理超时的任务
-                for task in pending:
-                    task_name = task.get_name()
-                    logger.warning(f"任务 '{task_name}' 关闭超时，强制取消")
+    async def shutdown(cls, timeout: float = 15.0) -> None:
+        """优雅关闭所有资源（单通道场景下简化关闭流程）"""
+        async with cls._shutdown_lock:
+            if cls._is_shutdown:
+                logger.info("RabbitMQService已关闭，无需重复操作")
+                return
+
+            cls._is_shutdown = True
+            logger.info("开始关闭RabbitMQ服务...")
+
+            # 1. 停止连接监控任务
+            if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+                cls._connection_monitor_task.cancel()
+                try:
+                    await asyncio.wait_for(cls._connection_monitor_task, timeout=timeout)
+                except asyncio.TimeoutError:
+                    logger.warning("连接监控任务关闭超时")
+                except Exception as e:
+                    logger.error(f"关闭连接监控任务失败: {str(e)}")
+
+            # 2. 停止所有消费者任务
+            for client_name, task in cls._consumer_tasks.items():
+                if not task.done():
+                    # 触发停止事件
+                    if client_name in cls._consumer_events:
+                        cls._consumer_events[client_name].set()
+                    # 取消任务
                     task.cancel()
                     try:
-                        await task
-                    except (asyncio.CancelledError, RuntimeError):
-                        pass
-
-            except Exception as e:
-                logger.error(f"等待消费者任务完成时出错: {str(e)}")
+                        await asyncio.wait_for(task, timeout=timeout)
+                    except Exception as e:
+                        logger.error(f"关闭消费者 '{client_name}' 失败: {str(e)}")
 
-        # 关闭所有客户端连接
-        remaining_time = max(
-            0.0, timeout - (asyncio.get_event_loop().time() - start_time))
-        if remaining_time > 0 and cls._clients:
-            client_count = len(cls._clients)
-            client_timeout = remaining_time / client_count  # 平均分配剩余时间
+            # 3. 关闭所有客户端（单通道场景下客户端关闭仅清理状态）
+            for client in cls._clients.values():
+                try:
+                    await client.close()
+                except Exception as e:
+                    logger.error(f"关闭客户端失败: {str(e)}")
 
-            for name, client in cls._clients.items():
+            # 4. 关闭连接池（单通道池关闭会释放所有资源）
+            if cls._connection_pool and cls._connection_pool._initialized:
                 try:
-                    await asyncio.wait_for(client.close(), timeout=client_timeout)
+                    await cls._connection_pool.close()
+                    logger.info("RabbitMQ单通道连接池已关闭")
                 except Exception as e:
-                    logger.warning(f"关闭客户端 '{name}' 时出错: {str(e)}")
-                logger.info(f"客户端 '{name}' 已关闭")
-
-        # 清理所有状态
-        cls._clients.clear()
-        cls._consumer_tasks.clear()
-        cls._message_handlers.clear()
-        cls._sender_client_names.clear()
-        cls._consumer_events.clear()
-        cls._consumer_tags.clear()
-        cls._initialized_queues.clear()
-        cls._init_locks.clear()
-        cls._has_listeners = False
-        cls._has_senders = False
-
-        logger.info("RabbitMQ服务已完全关闭")
+                    logger.error(f"关闭连接池失败: {str(e)}")
+
+            # 5. 清理状态
+            cls._clients.clear()
+            cls._message_handlers.clear()
+            cls._consumer_tasks.clear()
+            cls._consumer_events.clear()
+            cls._consumer_tags.clear()
+            cls._sender_client_names.clear()
+            cls._init_locks.clear()
+            cls._config = None
+
+            logger.info("RabbitMQService已完全关闭")