sycommon-python-lib 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service.py

@@ -1,100 +1,115 @@
-from typing import Any, Callable, Coroutine, Dict, List, Tuple, Union, Optional, Type
 import asyncio
 import logging
+from typing import (
+    Callable, Coroutine, Dict, List, Optional, Type, Union, Any, Set
+)
 from pydantic import BaseModel
-from aio_pika.abc import AbstractIncomingMessage
+from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
 
-from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.models.sso_user import SsoUser
-from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+from sycommon.logging.kafka_log import SYLogger
+from .rabbitmq_client import RabbitMQClient
+
+logger = logging.getLogger(__name__)
 
 
 class RabbitMQService:
+    """
+    RabbitMQ服务封装，管理多个客户端实例，提供发送和接收消息的高级接口
+    负责客户端的创建、配置、生命周期管理和错误处理
+    """
+
     # 保存多个客户端实例
-    clients: Dict[str, RabbitMQClient] = {}
-    # 保存多个消费者任务
-    consumer_tasks: Dict[str, asyncio.Task] = {}
+    _clients: Dict[str, RabbitMQClient] = {}
     # 保存消息处理器
-    message_handlers: Dict[str, Callable] = {}
+    _message_handlers: Dict[str, Callable] = {}
+    # 保存消费者任务
+    _consumer_tasks: Dict[str, asyncio.Task] = {}
     # 保存配置信息
-    config: Optional[dict] = None
-    # 存储发送客户端的名称（即队列名）
-    sender_client_names: List[str] = []
+    _config: Optional[dict] = None
+    # 存储发送客户端的名称
+    _sender_client_names: List[str] = []
     # 用于控制消费者任务退出的事件
     _consumer_events: Dict[str, asyncio.Event] = {}
-    # 存储消费者标签，用于取消消费
-    _consumer_tags: Dict[str, str] = {}
-    # 跟踪已完成的初始化操作（全局状态）
-    _initialized_queues: Dict[str, Dict[str, bool]] = {}
-    # 添加异步锁
-    _init_lock: Dict[str, asyncio.Lock] = {}
+    # 存储消费者标签
+    _consumer_tags: Dict[str, ConsumerTag] = {}
+    # 跟踪已初始化的队列
+    _initialized_queues: Set[str] = set()
+    # 异步锁，确保初始化安全
+    _init_locks: Dict[str, asyncio.Lock] = {}
+    # 标记是否有监听器和发送器
     _has_listeners: bool = False
     _has_senders: bool = False
+    # 消费启动超时设置
+    CONSUMER_START_TIMEOUT = 30  # 30秒超时
 
     @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
-        # 获取 common 配置
-        cls.config = NacosService(config).share_configs.get(
+
+        # 获取MQ配置
+        cls._config = NacosService(config).share_configs.get(
             "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
-        cls.config["APP_NAME"] = config.get("Name", "")
+        cls._config["APP_NAME"] = config.get("Name", "")
+
+        # 打印关键配置信息（显示所有集群节点）
+        logger.info(
+            f"RabbitMQ服务初始化 - 集群节点: {cls._config.get('host')}, "
+            f"端口: {cls._config.get('port')}, "
+            f"虚拟主机: {cls._config.get('virtual-host')}, "
+            f"应用名: {cls._config.get('APP_NAME')}"
+        )
 
         # 保存发送器和监听器存在状态
         cls._has_listeners = has_listeners
         cls._has_senders = has_senders
 
-        return cls()
-
-    @classmethod
-    async def check_queue_exists(cls, channel, queue_name: str) -> bool:
-        """检查队列是否存在"""
-        try:
-            await channel.declare_queue(
-                name=queue_name,
-                passive=True  # 被动模式：仅检查队列是否存在
-            )
-            return True
-        except Exception as e:
-            return False
+        return cls
 
     @classmethod
-    def create_client(cls, mq_config: dict, queue_name: str, **kwargs):
-        """创建并返回新的RabbitMQClient实例，遵循队列创建规则"""
-        # 获取当前项目名
-        app_name = kwargs.get('app_name', cls.config.get(
-            "APP_NAME", "")) if cls.config else kwargs.get('app_name', "")
-
-        # 确保只在需要时处理一次队列名称
-        processed_queue_name = queue_name
-
-        # 通过上下文判断是否为发送器
-        # 发送器场景：当没有监听器时
+    async def _create_client(cls, mq_config: dict, queue_name: str, **kwargs) -> RabbitMQClient:
+        """
+        创建RabbitMQ客户端实例（支持集群节点列表）
+        """
+        app_name = kwargs.get('app_name', cls._config.get(
+            "APP_NAME", "")) if cls._config else ""
+
+        # 确定是否为发送器
         is_sender = not cls._has_listeners
 
-        # 核心逻辑：根据组件存在状态决定是否允许创建队列
-        # 1. 只有发送器：不允许创建队列
-        # 2. 只有监听器：允许创建队列
-        # 3. 两者都存在：允许创建队列（由监听器负责）
-        create_if_not_exists = cls._has_listeners  # 只要有监听器就允许创建
+        # 根据组件类型决定是否允许创建队列
+        create_if_not_exists = cls._has_listeners  # 只有监听器允许创建队列
 
-        # 当需要创建队列且是监听器时，拼接项目名
+        # 为监听器队列名称拼接应用名
+        processed_queue_name = queue_name
         if create_if_not_exists and not is_sender and processed_queue_name and app_name:
             if not processed_queue_name.endswith(f".{app_name}"):
                 processed_queue_name = f"{processed_queue_name}.{app_name}"
-                logging.debug(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
+                logger.info(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
+            else:
+                logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
 
-        logging.debug(
-            f"队列创建权限 - 监听器存在: {cls._has_listeners}, 发送器存在: {cls._has_senders}, "
-            f"是否发送器: {is_sender}, 允许创建: {create_if_not_exists}, 队列: {processed_queue_name}"
+        logger.debug(
+            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(
-            host=mq_config.get('host', ""),
-            port=mq_config.get('port', 0),
+            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', "/"),
@@ -110,342 +125,476 @@ class RabbitMQService:
             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
+            app_name=app_name,
+            reconnection_delay=kwargs.get('reconnection_delay', 1),
+            max_reconnection_attempts=kwargs.get(
+                'max_reconnection_attempts', 5),
+            heartbeat=kwargs.get('heartbeat', 60),
+            prefetch_count=kwargs.get('prefetch_count', 2),
+            message_process_timeout=kwargs.get('message_process_timeout', 30),
+            consumption_stall_threshold=kwargs.get(
+                'consumption_stall_threshold', 120)
         )
 
     @classmethod
-    async def setup_rabbitmq(
+    async def get_client(
         cls,
-        mq_config: dict,
         client_name: str = "default", ** kwargs
     ) -> RabbitMQClient:
-        """初始化RabbitMQ客户端并注册到服务中"""
-        if client_name not in cls._init_lock:
-            cls._init_lock[client_name] = asyncio.Lock()
-
-        async with cls._init_lock[client_name]:
-            if client_name in cls.clients:
-                client = cls.clients[client_name]
-                # 移除is_sender判断，通过上下文推断
+        """
+        获取或创建RabbitMQ客户端
+
+        :param client_name: 客户端名称
+        :param kwargs: 客户端参数
+        :return: RabbitMQClient实例
+        """
+        if not cls._config:
+            raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
+
+        # 确保锁存在
+        if client_name not in cls._init_locks:
+            cls._init_locks[client_name] = asyncio.Lock()
+
+        async with cls._init_locks[client_name]:
+            # 如果客户端已存在且连接有效，直接返回
+            if client_name in cls._clients:
+                client = cls._clients[client_name]
                 is_sender = not cls._has_listeners or (
                     not kwargs.get('create_if_not_exists', True))
 
                 if client.is_connected:
+                    # 如果是监听器但队列未初始化，重新连接
                     if not is_sender and not client.queue:
-                        logging.debug(f"客户端 '{client_name}' 存在但队列未初始化，重新连接")
+                        logger.debug(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
                         await client.connect(force_reconnect=True, declare_queue=True)
-                    else:
-                        logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
                     return client
                 else:
-                    logging.debug(f"客户端 '{client_name}' 存在但连接已关闭，重新连接")
+                    logger.debug(f"客户端 '{client_name}' 连接已关闭，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
                     await client.connect(declare_queue=not is_sender)
                     return client
 
+            # 创建新客户端
             initial_queue_name = kwargs.pop('queue_name', '')
-            # 移除is_sender参数，通过上下文推断
             is_sender = not cls._has_listeners or (
                 not kwargs.get('create_if_not_exists', True))
 
             # 发送器特殊处理
             if is_sender:
                 kwargs['create_if_not_exists'] = False
-
-                client = RabbitMQService.create_client(
-                    mq_config,
+                client = await cls._create_client(
+                    cls._config,
                     initial_queue_name,
-                    app_name=cls.config.get("APP_NAME", ""),
-                    **kwargs  # 不再传递is_sender参数
+                    app_name=cls._config.get("APP_NAME", ""),
+                    **kwargs
                 )
-
                 await client.connect(declare_queue=False)
-                cls.clients[client_name] = client
+                cls._clients[client_name] = client
                 return client
 
             # 监听器逻辑
             kwargs['create_if_not_exists'] = True
 
+            # 检查队列是否已初始化
             if initial_queue_name in cls._initialized_queues:
-                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
-                client = RabbitMQService.create_client(
-                    mq_config,
-                    initial_queue_name,
-                    # 不再传递is_sender参数
-                    app_name=cls.config.get("APP_NAME", ""), ** kwargs
+                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
+                cls._clients[client_name] = client
                 return client
 
-            client = RabbitMQService.create_client(
-                mq_config,
+            # 创建并连接客户端
+            client = await cls._create_client(
+                cls._config,
                 initial_queue_name,
-                app_name=cls.config.get("APP_NAME", ""),
-                **kwargs  # 不再传递is_sender参数
+                app_name=cls._config.get("APP_NAME", ""),
+                **kwargs
             )
 
             client.create_if_not_exists = True
-            logging.debug(
-                f"监听器客户端创建 - create_if_not_exists={client.create_if_not_exists}")
-
             await client.connect(declare_queue=True)
 
+            # 验证队列是否创建成功
             if not client.queue:
-                logging.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
+                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:
                     raise Exception(f"无法创建队列 '{initial_queue_name}'")
 
+            # 记录已初始化的队列
             final_queue_name = client.queue_name
+            if final_queue_name:
+                cls._initialized_queues.add(final_queue_name)
 
-            if final_queue_name not in cls._initialized_queues:
-                cls._initialized_queues[final_queue_name] = {
-                    "declared": True,
-                    "bound": True
-                }
-
-            cls.clients[client_name] = client
+            cls._clients[client_name] = client
             return client
 
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False):
-        """设置MQ发送客户端"""
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False) -> None:
+        """
+        设置消息发送器
+
+        :param senders: 发送器配置列表
+        :param has_listeners: 是否同时存在监听器
+        """
+        cls._has_senders = True
+        # 保存监听器存在状态
         cls._has_listeners = has_listeners
-        cls._has_senders = True  # 明确标记存在发送器
+        logger.info(f"开始设置 {len(senders)} 个消息发送器")
 
-        async def setup_sender_tasks():
-            for idx, sender_config in enumerate(senders):
-                try:
-                    if not sender_config.queue_name:
-                        raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
-
-                    normalized_name = sender_config.queue_name
-                    app_name = cls.config.get("APP_NAME", "")
-
-                    if app_name and normalized_name.endswith(f".{app_name}"):
-                        normalized_name = normalized_name[:-
-                                                          len(f".{app_name}")]
-                        logging.debug(
-                            f"发送器队列名称移除app-name后缀: {normalized_name}")
-
-                    if normalized_name in cls.sender_client_names:
-                        logging.debug(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)
-                    else:
-                        # 移除is_sender参数传递
-                        client = await cls.setup_rabbitmq(
-                            cls.config,
-                            client_name=normalized_name,
-                            exchange_type=sender_config.exchange_type,
-                            durable=sender_config.durable,
-                            auto_delete=sender_config.auto_delete,
-                            auto_parse_json=sender_config.auto_parse_json,
-                            queue_name=sender_config.queue_name,
-                            create_if_not_exists=False  # 仅通过此参数控制
-                        )
-
-                    if normalized_name not in cls.clients:
-                        cls.clients[normalized_name] = client
-                        logging.info(f"发送客户端 '{normalized_name}' 已添加")
-
-                    if normalized_name not in cls.sender_client_names:
-                        cls.sender_client_names.append(normalized_name)
-                        logging.info(f"发送客户端 '{normalized_name}' 初始化成功")
+        for idx, sender_config in enumerate(senders):
+            try:
+                if not sender_config.queue_name:
+                    raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
+
+                queue_name = sender_config.queue_name
+                app_name = cls._config.get(
+                    "APP_NAME", "") if cls._config else ""
+
+                # 处理发送器队列名称，移除可能的app-name后缀
+                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}")
+
+                # 检查是否已初始化
+                if normalized_name in cls._sender_client_names:
+                    logger.debug(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)
+                else:
+                    client = await cls.get_client(
+                        client_name=normalized_name,
+                        exchange_type=sender_config.exchange_type,
+                        durable=sender_config.durable,
+                        auto_delete=sender_config.auto_delete,
+                        auto_parse_json=sender_config.auto_parse_json,
+                        queue_name=queue_name,
+                        create_if_not_exists=False
+                    )
 
-                except Exception as e:
-                    logging.error(
-                        f"初始化发送客户端第{idx+1}项失败: {str(e)}", exc_info=True)
+                # 记录客户端
+                if normalized_name not in cls._clients:
+                    cls._clients[normalized_name] = client
+                    logger.info(f"发送客户端 '{normalized_name}' 已添加")
 
-        try:
-            await setup_sender_tasks()
-        except Exception as e:
-            logging.error(f"设置发送器时发生错误: {str(e)}", exc_info=True)
-            raise
+                if normalized_name not in cls._sender_client_names:
+                    cls._sender_client_names.append(normalized_name)
+                    logger.info(f"发送客户端 '{normalized_name}' 初始化成功")
+
+            except Exception as e:
+                logger.error(
+                    f"初始化发送客户端第{idx+1}项失败: {str(e)}", exc_info=True)
+
+        logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False):
-        """设置MQ监听器 - 确保自动创建队列"""
-        # 存在监听器，设置标志
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False) -> None:
+        """
+        设置消息监听器
+
+        :param listeners: 监听器配置列表
+        :param has_senders: 是否同时存在发送器
+        """
         cls._has_listeners = True
+        # 保存发送器存在状态
+        cls._has_senders = has_senders
+        logger.info(f"开始设置 {len(listeners)} 个消息监听器")
+
+        for idx, listener_config in enumerate(listeners):
+            try:
+                # 转换配置并强制设置create_if_not_exists为True
+                listener_dict = listener_config.model_dump()
+                listener_dict['create_if_not_exists'] = True
+                queue_name = listener_dict['queue_name']
+
+                logger.info(f"设置监听器 {idx+1}/{len(listeners)}: {queue_name}")
+
+                # 添加监听器
+                await cls.add_listener(**listener_dict)
+            except Exception as e:
+                logger.error(
+                    f"设置监听器 {idx+1} 失败: {str(e)}", exc_info=True)
+                logger.warning("继续处理其他监听器")
 
-        for listener_config in listeners:
-            # 将监听器配置转换为字典并添加到监听器
-            # 强制设置create_if_not_exists为True
-            listener_dict = listener_config.model_dump()
-            listener_dict['create_if_not_exists'] = True
-            await cls.add_listener(**listener_dict)
         # 启动所有消费者
         await cls.start_all_consumers()
 
+        # 验证消费者启动结果
+        await cls._verify_consumers_started()
+
+        logger.info(f"消息监听器设置完成")
+
+    @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:
+
+            running_clients = [
+                name for name, task in cls._consumer_tasks.items()
+                if not task.done() and name in cls._consumer_tags
+            ]
+
+            logger.info(
+                f"消费者启动验证: {len(running_clients)}/{len(required_clients)} 已启动")
+            await asyncio.sleep(2)
+
+        # 检查未成功启动的消费者
+        failed_clients = [
+            name for name in required_clients if name not in running_clients]
+        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))
+
     @classmethod
     async def add_listener(
         cls,
         queue_name: str,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine], ** kwargs
+        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], ** kwargs
     ) -> None:
-        """添加RabbitMQ监听器 - 确保自动创建队列并拼接app-name"""
-        if not cls.config:
+        """
+        添加消息监听器
+
+        :param queue_name: 队列名称
+        :param handler: 消息处理函数
+        :param kwargs: 其他参数
+        """
+        if not cls._config:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
-        if queue_name in cls.message_handlers:
-            logging.debug(f"监听器 '{queue_name}' 已存在，跳过重复添加")
+        if queue_name in cls._message_handlers:
+            logger.debug(f"监听器 '{queue_name}' 已存在，跳过重复添加")
             return
 
-        # 为监听器强制设置create_if_not_exists=True
-        kwargs['create_if_not_exists'] = True
-
-        # 创建并初始化客户端（会处理队列名称）
-        await cls.setup_rabbitmq(
-            cls.config,
+        # 创建并初始化客户端
+        await cls.get_client(
             client_name=queue_name,
             queue_name=queue_name,
             **kwargs
         )
 
         # 注册消息处理器
-        cls.register_handler(queue_name, handler)
-
-    @classmethod
-    def register_handler(
-        cls,
-        client_name: str,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine]
-    ) -> None:
-        """为特定客户端注册消息处理器"""
-        cls.message_handlers[client_name] = handler
+        cls._message_handlers[queue_name] = handler
+        logger.info(f"监听器 '{queue_name}' 已添加")
 
     @classmethod
     async def start_all_consumers(cls) -> None:
-        """启动所有已注册客户端的消费者"""
-        for client_name in cls.clients:
+        """启动所有已注册的消费者"""
+        for client_name in cls._message_handlers:
             await cls.start_consumer(client_name)
 
     @classmethod
-    async def start_consumer(cls, client_name: str = "default") -> None:
-        """启动指定客户端的消费者"""
-        if client_name in cls.consumer_tasks and not cls.consumer_tasks[client_name].done():
-            logging.debug(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+    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}' 已在运行中，无需重复启动")
             return
 
-        if client_name not in cls.clients:
+        if client_name not in cls._clients:
             raise ValueError(f"RabbitMQ客户端 '{client_name}' 未初始化")
 
-        client = cls.clients[client_name]
-        handler = cls.message_handlers.get(client_name)
+        client = cls._clients[client_name]
+        handler = cls._message_handlers.get(client_name)
 
         if not handler:
-            logging.warning(f"未找到客户端 '{client_name}' 的处理器，使用默认处理器")
+            logger.warning(f"未找到客户端 '{client_name}' 的处理器，使用默认处理器")
             handler = cls.default_message_handler
 
+        # 设置消息处理器
         client.set_message_handler(handler)
 
+        # 确保客户端已连接
+        start_time = asyncio.get_event_loop().time()
+        while not client.is_connected:
+            if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
+                raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
+
+            logger.debug(f"等待客户端 '{client_name}' 连接就绪...")
+            await asyncio.sleep(1)
+
+        # 创建停止事件
         stop_event = asyncio.Event()
         cls._consumer_events[client_name] = stop_event
 
+        # 定义消费任务
         async def consume_task():
             try:
-                consumer_tag = await client.start_consuming()
+                # 启动消费，带重试机制
+                max_attempts = 5
+                attempt = 0
+                consumer_tag = None
+
+                while attempt < max_attempts and not stop_event.is_set():
+                    try:
+                        consumer_tag = await client.start_consuming()
+                        if consumer_tag:
+                            break
+                    except Exception as e:
+                        attempt += 1
+                        logger.warning(
+                            f"启动消费者尝试 {attempt}/{max_attempts} 失败: {str(e)}")
+                        if attempt < max_attempts:
+                            await asyncio.sleep(2)
+
+                if not consumer_tag:
+                    raise Exception(f"经过 {max_attempts} 次尝试仍无法启动消费者")
+
+                # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
-                logging.info(f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
-
-                while not stop_event.is_set():
-                    await asyncio.sleep(0.1)
+                logger.info(f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
 
-                logging.info(f"消费者 '{client_name}' 退出循环")
+                # 等待停止事件
+                await stop_event.wait()
+                logger.info(f"收到停止信号，消费者 '{client_name}' 准备退出")
 
             except asyncio.CancelledError:
-                logging.info(f"消费者 '{client_name}' 被取消")
+                logger.info(f"消费者 '{client_name}' 被取消")
             except Exception as e:
-                logging.error(
+                logger.error(
                     f"消费者 '{client_name}' 错误: {str(e)}", exc_info=True)
+                # 非主动停止时尝试重启
+                if not stop_event.is_set():
+                    logger.info(f"尝试重启消费者 '{client_name}'")
+                    asyncio.create_task(cls.start_consumer(client_name))
             finally:
-                await client.stop_consuming()
-                logging.info(f"消费者 '{client_name}' 已完成清理")
+                # 清理资源
+                try:
+                    await client.stop_consuming()
+                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:
+                    del cls._consumer_events[client_name]
+
+                logger.info(f"消费者 '{client_name}' 已停止")
+
+        # 创建并跟踪消费任务
         task = asyncio.create_task(
             consume_task(), name=f"consumer-{client_name}")
-        cls.consumer_tasks[client_name] = task
+        cls._consumer_tasks[client_name] = task
 
-        def task_exception_handler(t: asyncio.Task):
+        # 添加任务完成回调
+        def task_done_callback(t: asyncio.Task) -> None:
             try:
                 if t.done():
                     t.result()
             except Exception as e:
-                logging.error(f"消费者任务 '{client_name}' 异常: {str(e)}")
+                logger.error(f"消费者任务 '{client_name}' 异常结束: {str(e)}")
+                # 任务异常时自动重启（如果服务未关闭）
+                if client_name in cls._message_handlers:  # 检查处理器是否仍存在
+                    asyncio.create_task(cls.start_consumer(client_name))
 
-        task.add_done_callback(task_exception_handler)
+        task.add_done_callback(task_done_callback)
+        logger.info(f"消费者任务 '{client_name}' 已创建")
 
     @classmethod
-    async def default_message_handler(cls, parsed_data: MQMsgModel, original_message):
+    async def default_message_handler(cls, parsed_data: MQMsgModel, original_message: AbstractIncomingMessage) -> None:
         """默认消息处理器"""
-        logging.info(f"\n===== 收到消息 [{original_message.routing_key}] =====")
-        logging.info(f"关联ID: {parsed_data.correlationDataId}")
-        logging.info(f"主题代码: {parsed_data.topicCode}")
-        logging.info(f"消息内容: {parsed_data.msg}")
-        logging.info("===================\n")
+        logger.info(f"\n===== 收到消息 [{original_message.routing_key}] =====")
+        logger.info(f"关联ID: {parsed_data.correlationDataId}")
+        logger.info(f"主题代码: {parsed_data.topicCode}")
+        logger.info(f"消息内容: {parsed_data.msg}")
+        logger.info("===================\n")
 
     @classmethod
-    def get_sender(cls, client_name: Optional[str] = None) -> Optional[RabbitMQClient]:
-        """获取发送客户端（仅返回已注册的客户端）"""
-        if not client_name:
-            logging.warning("发送器名称不能为空")
+    def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
+        """
+        获取发送客户端
+
+        :param queue_name: 队列名称
+        :return: RabbitMQClient实例或None
+        """
+        if not queue_name:
+            logger.warning("发送器名称不能为空")
             return None
 
-        # 仅精确匹配已注册的客户端
-        if client_name in cls.clients:
-            return cls.clients[client_name]
+        # 检查是否在已注册的发送器中
+        if queue_name in cls._sender_client_names and queue_name in cls._clients:
+            return cls._clients[queue_name]
 
-        app_name = cls.config.get("APP_NAME", "") if cls.config else ""
-        if app_name and not client_name.endswith(f".{app_name}"):
-            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}")
 
-        logging.debug(f"发送器 '{client_name}' 不在已注册客户端列表中")
+        logger.debug(f"未找到发送器 '{queue_name}'")
         return None
 
     @classmethod
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: Optional[str] = None, **kwargs
+        queue_name: str, ** kwargs
     ) -> None:
-        """发送消息到RabbitMQ"""
+        """
+        发送消息到指定队列
+
+        :param data: 消息数据
+        :param queue_name: 队列名称
+        :param kwargs: 其他参数
+        """
+        # 获取发送客户端
         sender = cls.get_sender(queue_name)
-
         if not sender:
             error_msg = f"未找到可用的RabbitMQ发送器 (queue_name: {queue_name})"
-            logging.error(error_msg)
+            logger.error(error_msg)
             raise ValueError(error_msg)
 
-        if not sender.connection or sender.connection.is_closed:
-            logging.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
+        # 确保连接有效
+        if not sender.is_connected:
+            logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
             try:
                 await sender.connect(force_reconnect=True)
             except Exception as e:
-                logging.error(f"发送器 '{queue_name}' 重新连接失败: {str(e)}")
+                logger.error(f"发送器 '{queue_name}' 重新连接失败: {str(e)}")
                 raise
 
         try:
-            msg = ''
+            # 处理消息数据
+            msg_content = ""
             if isinstance(data, str):
-                msg = data
+                msg_content = data
             elif isinstance(data, BaseModel):
-                msg = data.model_dump_json()
+                msg_content = data.model_dump_json()
             elif isinstance(data, dict):
                 import json
-                msg = json.dumps(data)
+                msg_content = json.dumps(data)
 
+            # 创建标准消息模型
             mq_message = MQMsgModel(
                 topicCode=queue_name.split('.')[0] if queue_name else "",
-                msg=msg,
+                msg=msg_content,
                 correlationDataId=kwargs.get(
                     'correlationDataId', SYLogger.get_trace_id()),
                 groupId=kwargs.get('groupId', ''),
@@ -454,7 +603,7 @@ class RabbitMQService:
                 traceId=SYLogger.get_trace_id()
             )
 
-            # 不设置Java会解析失败导致丢掉消息
+            # 构建消息头
             mq_header = {
                 "context": SsoUser(
                     tenant_id="T000002",
@@ -467,67 +616,81 @@ class RabbitMQService:
                 ).model_dump_json()
             }
 
-            await sender.send_message(
+            # 发送消息
+            await sender.publish(
                 message_body=mq_message.model_dump_json(),
                 headers=mq_header,
+                content_type="application/json"
             )
-            logging.info(
-                f"消息发送成功 (客户端: {queue_name or cls.sender_client_names[0]})")
+            logger.info(f"消息发送成功 (队列: {queue_name})")
         except Exception as e:
-            logging.error(f"消息发送失败: {str(e)}", exc_info=True)
+            logger.error(f"消息发送失败: {str(e)}", exc_info=True)
             raise
 
     @classmethod
-    async def shutdown(cls, timeout: float = 5.0) -> None:
-        """优雅关闭所有客户端和消费者任务"""
+    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()
-            logging.info(f"已向消费者 '{client_name}' 发送退出信号")
+            logger.info(f"已向消费者 '{client_name}' 发送退出信号")
 
+        # 等待消费者任务完成
         remaining_time = max(
             0.0, timeout - (asyncio.get_event_loop().time() - start_time))
-        if remaining_time > 0:
-            tasks_to_wait = [
-                t for t in cls.consumer_tasks.values() if not t.done()]
-            if tasks_to_wait:
-                try:
-                    done, pending = await asyncio.wait(
-                        tasks_to_wait,
-                        timeout=remaining_time,
-                        return_when=asyncio.ALL_COMPLETED
-                    )
+        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()
-                        logging.warning(f"任务 '{task_name}' 关闭超时，强制取消")
-                        task.cancel()
-                        try:
-                            await task
-                        except (asyncio.CancelledError, RuntimeError):
-                            pass
+                # 处理超时的任务
+                for task in pending:
+                    task_name = task.get_name()
+                    logger.warning(f"任务 '{task_name}' 关闭超时，强制取消")
+                    task.cancel()
+                    try:
+                        await task
+                    except (asyncio.CancelledError, RuntimeError):
+                        pass
 
-                except Exception as e:
-                    logging.error(f"等待消费者任务完成时出错: {str(e)}")
+            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:
-            for name, client in cls.clients.items():
+        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:
-                    await asyncio.wait_for(client.stop_consuming(), timeout=remaining_time/len(cls.clients))
-                    await asyncio.wait_for(client.close(), timeout=remaining_time/len(cls.clients))
+                    await asyncio.wait_for(client.close(), timeout=client_timeout)
                 except Exception as e:
-                    logging.warning(f"关闭客户端 '{name}' 时出错: {str(e)}")
-                logging.info(f"RabbitMQ客户端 '{name}' 已关闭")
-
-        cls.consumer_tasks.clear()
+                    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.clients.clear()
-        cls.sender_client_names.clear()
-        cls._init_lock.clear()
-        cls._has_listeners = False  # 重置标志
+        cls._initialized_queues.clear()
+        cls._init_locks.clear()
+        cls._has_listeners = False
+        cls._has_senders = False
 
-        logging.info("RabbitMQ服务已完全关闭")
+        logger.info("RabbitMQ服务已完全关闭")