sycommon-python-lib 0.1.29__py3-none-any.whl → 0.1.38__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 from typing import (
     Callable, Coroutine, Dict, List, Optional, Type, Union, Any, Set
 )
@@ -18,6 +19,7 @@ logger = SYLogger
 class RabbitMQService:
     """
     RabbitMQ服务封装，管理多个客户端实例，基于连接池实现资源复用
+    适配细粒度锁设计的RabbitMQClient，确保线程安全
     """
 
     # 保存多个客户端实例
@@ -45,6 +47,10 @@ class RabbitMQService:
     CONSUMER_START_TIMEOUT = 30  # 30秒超时
     # 连接池实例
     _connection_pool: Optional[RabbitMQConnectionPool] = None
+    # 服务关闭标记
+    _is_shutdown: bool = False
+    # 服务关闭锁
+    _shutdown_lock = asyncio.Lock()
 
     @classmethod
     def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
@@ -53,6 +59,11 @@ class RabbitMQService:
         """
         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', {})
@@ -69,6 +80,7 @@ class RabbitMQService:
         # 保存发送器和监听器存在状态
         cls._has_listeners = has_listeners
         cls._has_senders = has_senders
+        cls._is_shutdown = False
 
         # 初始化连接池（在单独的异步方法中启动）
         asyncio.create_task(cls._init_connection_pool())
@@ -77,8 +89,8 @@ class RabbitMQService:
 
     @classmethod
     async def _init_connection_pool(cls):
-        """初始化连接池（异步操作）"""
-        if cls._connection_pool or not cls._config:
+        """初始化连接池（异步操作，带重试）"""
+        if cls._connection_pool or not cls._config or cls._is_shutdown:
             return
 
         try:
@@ -105,24 +117,31 @@ class RabbitMQService:
             )
 
             # 初始化连接池
-            await cls._connection_pool.init_pools()
+            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)
-            # 连接池初始化失败时重试
-            await asyncio.sleep(1)
-            asyncio.create_task(cls._init_connection_pool())
+            # 连接池初始化失败时重试（未关闭状态下）
+            if not cls._is_shutdown:
+                await asyncio.sleep(3)
+                asyncio.create_task(cls._init_connection_pool())
 
     @classmethod
     async def _create_client(cls, queue_name: str, **kwargs) -> RabbitMQClient:
+        """创建客户端实例（适配新的RabbitMQClient API）"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
+
         if not cls._connection_pool:
             # 等待连接池初始化
             start_time = asyncio.get_event_loop().time()
-            while not cls._connection_pool:
+            while not cls._connection_pool 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 ""
@@ -142,12 +161,12 @@ 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}"
         )
 
-        # 创建客户端实例
+        # 创建客户端实例（适配新的RabbitMQClient参数）
         client = RabbitMQClient(
             connection_pool=cls._connection_pool,
             exchange_name=cls._config.get(
@@ -161,17 +180,24 @@ class RabbitMQService:
             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),
+            rpc_timeout=kwargs.get('rpc_timeout', 10),
             reconnection_delay=kwargs.get('reconnection_delay', 1),
             max_reconnection_attempts=kwargs.get(
                 'max_reconnection_attempts', 5),
             prefetch_count=kwargs.get('prefetch_count', 2),
             consumption_stall_threshold=kwargs.get(
-                'consumption_stall_threshold', 10)
+                'consumption_stall_threshold', 60),  # 延长停滞阈值
         )
 
         # 使用declare_queue控制是否声明队列（发送器不声明，监听器声明）
         await client.connect(declare_queue=not is_sender)
+
+        # 监听器客户端连接后延迟1秒，确保消费状态就绪（仅首次启动）
+        if not is_sender and create_if_not_exists:
+            logger.info(
+                f"监听器客户端 '{processed_queue_name}' 连接成功，延迟1秒启动消费（解决启动时序问题）")
+            await asyncio.sleep(1)
+
         return client
 
     @classmethod
@@ -180,18 +206,24 @@ class RabbitMQService:
         client_name: str = "default", ** kwargs
     ) -> RabbitMQClient:
         """
-        获取或创建RabbitMQ客户端（基于连接池）
+        获取或创建RabbitMQ客户端（基于连接池，线程安全）
+        适配新的RabbitMQClient异步状态检查
         """
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
+
         if not cls._config:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
         # 等待连接池就绪
         if not cls._connection_pool:
             start_time = asyncio.get_event_loop().time()
-            while not cls._connection_pool:
+            while not cls._connection_pool 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:
@@ -204,15 +236,19 @@ class RabbitMQService:
                 is_sender = not cls._has_listeners or (
                     not kwargs.get('create_if_not_exists', True))
 
-                if client.is_connected:
+                # 异步检查连接状态（适配新客户端的async属性）
+                if await client.is_connected:
                     # 如果是监听器但队列未初始化，重新连接
-                    if not is_sender and not client.queue:
-                        logger.debug(f"客户端 '{client_name}' 队列未初始化，重新连接")
-                        client.create_if_not_exists = True
-                        await client.connect(force_reconnect=True, declare_queue=True)
+                    if not is_sender:
+                        # 异步获取队列（适配新客户端的原子方法）
+                        _, _, queue = await client._get_connection_resources()
+                        if not queue:
+                            logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
+                            client.create_if_not_exists = True
+                            await client.connect(force_reconnect=True, declare_queue=True)
                     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)
@@ -240,7 +276,7 @@ class RabbitMQService:
 
             # 检查队列是否已初始化
             if initial_queue_name in cls._initialized_queues:
-                logger.debug(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
+                logger.info(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
                 client = await cls._create_client(
                     initial_queue_name, ** kwargs
                 )
@@ -258,12 +294,14 @@ class RabbitMQService:
             client.create_if_not_exists = True
             await client.connect(declare_queue=True)
 
-            # 验证队列是否创建成功
-            if not client.queue:
+            # 验证队列是否创建成功（异步获取队列）
+            _, _, queue = await client._get_connection_resources()
+            if not 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:
+                _, _, queue = await client._get_connection_resources()
+                if not queue:
                     raise Exception(f"无法创建队列 '{initial_queue_name}'")
 
             # 记录已初始化的队列
@@ -274,10 +312,13 @@ class RabbitMQService:
             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
+
         cls._has_senders = True
         cls._has_listeners = has_listeners
         logger.info(f"开始设置 {len(senders)} 个消息发送器")
@@ -287,6 +328,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 ""
@@ -295,17 +337,17 @@ 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:
+                    if not await client.is_connected:
                         await client.connect(declare_queue=False)
                 else:
                     client = await cls.get_client(
@@ -315,7 +357,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
                     )
 
                 # 记录客户端
@@ -334,8 +378,12 @@ 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
+
         cls._has_listeners = True
         cls._has_senders = has_senders
         logger.info(f"开始设置 {len(listeners)} 个消息监听器")
@@ -366,13 +414,14 @@ class RabbitMQService:
 
     @classmethod
     async def _verify_consumers_started(cls, timeout: int = 30) -> None:
-        """验证消费者是否成功启动"""
+        """验证消费者是否成功启动（适配新客户端的消费者标签管理）"""
         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()
@@ -384,7 +433,7 @@ class RabbitMQService:
             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:
@@ -397,12 +446,16 @@ class RabbitMQService:
         queue_name: str,
         handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], ** kwargs
     ) -> None:
-        """添加消息监听器"""
+        """添加消息监听器（线程安全）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法添加监听器")
+            return
+
         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
 
         # 创建并初始化客户端
@@ -418,15 +471,23 @@ 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:
-        """启动指定客户端的消费者"""
+        """启动指定客户端的消费者（适配新客户端的消费API）"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法启动消费者")
+            return
+
         if client_name in cls._consumer_tasks and not cls._consumer_tasks[client_name].done():
-            logger.debug(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+            logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
             return
 
         if client_name not in cls._clients:
@@ -439,16 +500,24 @@ class RabbitMQService:
             logger.warning(f"未找到客户端 '{client_name}' 的处理器，使用默认处理器")
             handler = cls.default_message_handler
 
-        # 设置消息处理器
-        client.set_message_handler(handler)
+        # 设置消息处理器（适配新客户端的async方法）
+        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:
+            logger.info("服务关闭中，取消启动消费者")
+            return
+
+        # 监听器启动消费前额外延迟1秒，确保consumer_tag完全生成（不删消息）
+        if cls._has_listeners and not client_name.startswith("sender-"):
+            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪（不删除积压消息）")
             await asyncio.sleep(1)
 
         # 创建停止事件
@@ -463,8 +532,18 @@ class RabbitMQService:
                 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(force_reconnect=True, declare_queue=True)
+
+                        # 确保队列已就绪
+                        _, _, queue = await client._get_connection_resources()
+                        if not queue:
+                            raise Exception("队列未初始化完成")
+
                         consumer_tag = await client.start_consuming()
                         if consumer_tag:
                             break
@@ -475,12 +554,17 @@ class RabbitMQService:
                         if attempt < max_attempts:
                             await asyncio.sleep(1)
 
+                if cls._is_shutdown:
+                    logger.info("服务关闭中，消费者启动中止")
+                    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}（将处理队列中所有积压消息）")
 
                 # 等待停止事件
                 await stop_event.wait()
@@ -492,8 +576,10 @@ 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(3)
                     asyncio.create_task(cls.start_consumer(client_name))
             finally:
                 # 清理资源
@@ -502,7 +588,7 @@ class RabbitMQService:
                 except Exception as e:
                     logger.error(f"停止消费者 '{client_name}' 时出错: {str(e)}")
 
-                # 移除状态记录
+                # 移除状态记录（线程安全）
                 if client_name in cls._consumer_tags:
                     del cls._consumer_tags[client_name]
                 if client_name in cls._consumer_events:
@@ -523,7 +609,7 @@ class RabbitMQService:
             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)
@@ -539,22 +625,50 @@ 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
+
         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(declare_queue=False)
+                    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(declare_queue=False)
+                        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
@@ -563,28 +677,32 @@ class RabbitMQService:
         data: Union[BaseModel, str, Dict[str, Any], None],
         queue_name: str, ** kwargs
     ) -> None:
-        """发送消息到指定队列"""
-        # 获取发送客户端
-        sender = cls.get_sender(queue_name)
+        """发送消息到指定队列（适配新客户端的publish API）"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法发送消息")
+
+        # 获取发送客户端（异步方法）
+        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}' 连接已关闭，尝试重新连接")
             max_retry = 3  # 最大重试次数
             retry_count = 0
             last_exception = None
 
-            while retry_count < max_retry:
+            while retry_count < max_retry and not cls._is_shutdown:
                 try:
                     # 尝试重连，每次重试间隔1秒
                     await sender.connect(force_reconnect=True, declare_queue=False)
-                    logger.info(
-                        f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
-                    break  # 重连成功则退出循环
+                    if await sender.is_connected:
+                        logger.info(
+                            f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
+                        break  # 重连成功则退出循环
                 except Exception as e:
                     last_exception = e
                     retry_count += 1
@@ -595,7 +713,7 @@ class RabbitMQService:
                         await asyncio.sleep(1)  # 重试前等待1秒
 
             # 所有重试都失败则抛出异常
-            if retry_count >= max_retry and not sender.is_connected:
+            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
@@ -608,8 +726,7 @@ 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(
@@ -636,7 +753,7 @@ class RabbitMQService:
                 ).model_dump_json()
             }
 
-            # 发送消息
+            # 发送消息（适配新客户端的publish方法）
             await sender.publish(
                 message_body=mq_message.model_dump_json(),
                 headers=mq_header,
@@ -648,73 +765,80 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def shutdown(cls, timeout: float = 10.0) -> None:
-        """优雅关闭所有资源（新增连接池关闭逻辑）"""
-        start_time = asyncio.get_event_loop().time()
-        logger.info("开始关闭RabbitMQ服务...")
+    async def shutdown(cls, timeout: float = 15.0) -> None:
+        """优雅关闭所有资源（线程安全，适配新客户端的close API）"""
+        async with cls._shutdown_lock:
+            if cls._is_shutdown:
+                logger.info("RabbitMQService已关闭，无需重复操作")
+                return
+
+            cls._is_shutdown = True
+            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() - asyncio.get_event_loop().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 client_name, event in cls._consumer_events.items():
-            event.set()
-            logger.info(f"已向消费者 '{client_name}' 发送退出信号")
+                    # 处理超时的任务
+                    for task in pending:
+                        task_name = task.get_name()
+                        logger.warning(f"任务 '{task_name}' 关闭超时，强制取消")
+                        task.cancel()
+                        try:
+                            await task
+                        except (asyncio.CancelledError, RuntimeError):
+                            pass
 
-        # 等待消费者任务完成
-        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
-                )
+                except Exception as e:
+                    logger.error(f"等待消费者任务完成时出错: {str(e)}")
 
-                # 处理超时的任务
-                for task in pending:
-                    task_name = task.get_name()
-                    logger.warning(f"任务 '{task_name}' 关闭超时，强制取消")
-                    task.cancel()
-                    try:
-                        await task
-                    except (asyncio.CancelledError, RuntimeError):
-                        pass
+            # 关闭所有客户端连接（适配新客户端的async close方法）
+            remaining_time = max(
+                0.0, timeout - (asyncio.get_event_loop().time() - asyncio.get_event_loop().time()))
+            if remaining_time > 0 and cls._clients:
+                client_count = len(cls._clients)
+                client_timeout = remaining_time / client_count  # 平均分配剩余时间
 
-            except Exception as e:
-                logger.error(f"等待消费者任务完成时出错: {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  # 平均分配剩余时间
+                for name, client in cls._clients.items():
+                    try:
+                        if await client.is_connected:
+                            await asyncio.wait_for(client.close(), timeout=client_timeout)
+                    except Exception as e:
+                        logger.warning(f"关闭客户端 '{name}' 时出错: {str(e)}")
+                    logger.info(f"客户端 '{name}' 已关闭")
 
-            for name, client in cls._clients.items():
+            # 关闭连接池
+            if cls._connection_pool:
                 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}' 已关闭")
-
-        # 关闭连接池
-        if cls._connection_pool:
-            try:
-                await cls._connection_pool.close()
-                logger.info("RabbitMQ连接池已关闭")
-            except Exception as e:
-                logger.warning(f"关闭连接池时出错: {str(e)}")
-
-        # 清理所有状态
-        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
-        cls._connection_pool = None
-
-        logger.info("RabbitMQ服务已完全关闭")
+                    logger.warning(f"关闭连接池时出错: {str(e)}")
+
+            # 清理所有状态
+            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
+            cls._connection_pool = None
+            cls._config = None
+
+            logger.info("RabbitMQ服务已完全关闭")