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

sycommon/rabbitmq/rabbitmq_client.py

@@ -1,40 +1,37 @@
+from aio_pika import Channel
+from typing import Optional
 import asyncio
-import logging
 import json
-from typing import Callable, Coroutine, Optional, Dict, Any, Union, Set, List
-from aio_pika import connect_robust, Message, DeliveryMode, ExchangeType
+from typing import Callable, Coroutine, Dict, Any, Union
+from aio_pika import Message, DeliveryMode, ExchangeType
 from aio_pika.abc import (
-    AbstractConnection,
-    AbstractChannel,
     AbstractExchange,
     AbstractQueue,
     AbstractIncomingMessage,
-    ConsumerTag
+    ConsumerTag,
+    AbstractRobustConnection,
 )
-from aiormq.exceptions import ChannelInvalidStateError, ConnectionClosed
-
+from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
-# 最大重试次数限制
-MAX_RETRY_COUNT = 3
-
 logger = SYLogger
 
 
 class RabbitMQClient:
     """
-    RabbitMQ客户端，支持集群多节点配置，基于aio-pika实现
-    提供自动故障转移、连接恢复和消息可靠性保障
+    RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
+    核心特性：
+    1. 基于单通道连接池复用资源，性能优化
+    2. 依赖连接池原生自动重连，客户端仅重建自身资源
+    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
+    4. 消费支持手动ACK/NACK
+    5. 兼容JSON/字符串/字典消息格式
     """
 
     def __init__(
         self,
-        hosts: List[str],
-        port: int,
-        username: str,
-        password: str,
-        virtualhost: str = "/",
+        connection_pool: RabbitMQConnectionPool,
         exchange_name: str = "system.topic.exchange",
         exchange_type: str = "topic",
         queue_name: Optional[str] = None,
@@ -43,859 +40,418 @@ class RabbitMQClient:
         auto_delete: bool = False,
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
-        connection_timeout: int = 10,
-        rpc_timeout: int = 10,
-        app_name: str = "",
-        reconnection_delay: int = 1,
-        max_reconnection_attempts: int = 5,
-        heartbeat: int = 10,
-        prefetch_count: int = 2,
-        consumption_stall_threshold: int = 10
+        **kwargs,
     ):
-        """
-        初始化RabbitMQ客户端，支持集群多节点配置
-
-        :param hosts: RabbitMQ主机地址列表（集群节点）
-        :param port: RabbitMQ端口
-        :param username: 用户名
-        :param password: 密码
-        :param virtualhost: 虚拟主机
-        :param exchange_name: 交换机名称
-        :param exchange_type: 交换机类型
-        :param queue_name: 队列名称
-        :param routing_key: 路由键
-        :param durable: 是否持久化
-        :param auto_delete: 是否自动删除
-        :param auto_parse_json: 是否自动解析JSON消息
-        :param create_if_not_exists: 如果资源不存在是否创建
-        :param connection_timeout: 连接超时时间(秒)
-        :param rpc_timeout: RPC操作超时时间(秒)
-        :param app_name: 应用名称，用于标识连接
-        :param reconnection_delay: 重连延迟(秒)
-        :param max_reconnection_attempts: 最大重连尝试次数
-        :param heartbeat: 心跳间隔(秒)
-        :param prefetch_count: 预取消息数量
-        :param consumption_stall_threshold: 消费停滞检测阈值(秒)
-        """
-        # 连接参数 - 支持多主机
-        self.hosts = [host.strip() for host in hosts if host.strip()]
-        if not self.hosts:
-            raise ValueError("至少需要提供一个RabbitMQ主机地址")
-        self.port = port
-        self.username = username
-        self.password = password
-        self.virtualhost = virtualhost
-        self.app_name = app_name or "rabbitmq-client"
-
-        # 交换器和队列参数
-        self.exchange_name = exchange_name
-        self.exchange_type = ExchangeType(exchange_type)
-        self.queue_name = queue_name
-        self.routing_key = routing_key
-        self.durable = durable
-        self.auto_delete = auto_delete
-
-        # 行为控制参数
-        self.auto_parse_json = auto_parse_json
-        self.create_if_not_exists = create_if_not_exists
-        self.connection_timeout = connection_timeout
-        self.rpc_timeout = rpc_timeout
-        self.prefetch_count = prefetch_count
-
-        # 重连和保活参数
-        self.reconnection_delay = reconnection_delay
-        self.max_reconnection_attempts = max_reconnection_attempts
-        self.heartbeat = heartbeat
-
-        # 消息处理参数
-        self.consumption_stall_threshold = consumption_stall_threshold
-
-        # 连接和通道对象
-        self.connection: Optional[AbstractConnection] = None
-        self.channel: Optional[AbstractChannel] = None
-        self.exchange: Optional[AbstractExchange] = None
-        self.queue: Optional[AbstractQueue] = None
-
-        # 当前活跃连接的主机
-        self._active_host: Optional[str] = None
-
-        # 状态跟踪
-        self.actual_queue_name: Optional[str] = None
-        self._exchange_exists = False
-        self._queue_exists = False
-        self._queue_bound = False
-        self._is_consuming = False
-        self._closed = False
+        # 依赖注入：连接池（必须已初始化）
+        self.connection_pool = connection_pool
+        if not self.connection_pool._initialized:
+            raise RuntimeError("连接池未初始化，请先调用 connection_pool.init_pools()")
+
+        # 交换机配置
+        self.exchange_name = exchange_name.strip()
+        try:
+            self.exchange_type = ExchangeType(exchange_type.lower())
+        except ValueError:
+            logger.warning(f"无效的exchange_type: {exchange_type}，默认使用'topic'")
+            self.exchange_type = ExchangeType.TOPIC
+
+        # 队列配置
+        self.queue_name = queue_name.strip() if queue_name else None
+        self.routing_key = routing_key.strip() if routing_key else "#"
+        self.durable = durable  # 消息/队列持久化
+        self.auto_delete = auto_delete  # 无消费者时自动删除队列/交换机
+        self.auto_parse_json = auto_parse_json  # 自动解析JSON消息体
+        self.create_if_not_exists = create_if_not_exists  # 不存在则创建交换机/队列
+
+        # 内部状态（资源+连接）
+        self._channel: Optional[Channel] = None
+        self._channel_conn: Optional[AbstractRobustConnection] = None  # 通道所属连接
+        self._exchange: Optional[AbstractExchange] = None
+        self._queue: Optional[AbstractQueue] = None
         self._consumer_tag: Optional[ConsumerTag] = None
-        self._last_activity_timestamp = asyncio.get_event_loop().time()
-        self._last_message_processed = asyncio.get_event_loop().time()
-
-        # 任务和处理器
-        self.message_handler: Optional[Callable[
-            [Union[Dict[str, Any], str], AbstractIncomingMessage],
-            Coroutine[Any, Any, None]
-        ]] = None
-        self._consuming_task: Optional[asyncio.Task] = None
-        self._reconnect_task: Optional[asyncio.Task] = None
-        self._keepalive_task: Optional[asyncio.Task] = None
-        self._monitor_task: Optional[asyncio.Task] = None
-
-        # 消息处理跟踪
-        self._processing_message_ids: Set[str] = set()
+        self._message_handler: Optional[Callable[[
+            MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = None
+        self._closed = False
+
+        # 线程安全锁
+        self._consume_lock = asyncio.Lock()
+        self._connect_lock = asyncio.Lock()
+        # 跟踪连接关闭回调（用于后续移除）
+        self._conn_close_callback: Optional[Callable] = None
+        # 控制重连频率的信号量（限制并发重连数）
+        self._reconnect_semaphore = asyncio.Semaphore(1)
+        # 固定重连间隔15秒（全局统一）
+        self._RECONNECT_INTERVAL = 15
+        # 跟踪当前重连任务（避免重复创建）
+        self._current_reconnect_task: Optional[asyncio.Task] = None
+        # 连接失败计数器（用于告警）
+        self._reconnect_fail_count = 0
+        # 连接失败告警阈值
+        self._reconnect_alert_threshold = 5
 
     @property
-    def is_connected(self) -> bool:
-        """检查连接是否有效"""
-        return (not self._closed and
-                self.connection is not None and
-                not self.connection.is_closed and
-                self.channel is not None and
-                not self.channel.is_closed and
-                self.exchange is not None)
-
-    def _update_activity_timestamp(self) -> None:
-        """更新最后活动时间戳"""
-        self._last_activity_timestamp = asyncio.get_event_loop().time()
-
-    def _update_message_processed_timestamp(self) -> None:
-        """更新最后消息处理时间戳"""
-        self._last_message_processed = asyncio.get_event_loop().time()
-
-    async def _check_exchange_exists(self) -> bool:
-        """检查交换机是否存在"""
-        if not self.channel:
+    async def is_connected(self) -> bool:
+        """异步检查客户端连接状态（属性，不可调用）"""
+        if self._closed:
             return False
-
         try:
-            # 使用被动模式检查交换机是否存在
-            await asyncio.wait_for(
-                self.channel.declare_exchange(
-                    name=self.exchange_name,
-                    type=self.exchange_type,
-                    passive=True
-                ),
-                timeout=self.rpc_timeout
+            # 单通道场景：校验通道+连接+核心资源都有效
+            return (
+                self._channel and not self._channel.is_closed
+                and self._channel_conn and not self._channel_conn.is_closed
+                and self._exchange is not None
+                and (not self.queue_name or self._queue is not None)
             )
-            self._exchange_exists = True
-            self._update_activity_timestamp()
-            return True
-        except asyncio.TimeoutError:
-            logger.error(
-                f"检查交换机 '{self.exchange_name}' 超时 (主机: {self._active_host})")
-            return False
         except Exception as e:
-            logger.debug(
-                f"交换机 '{self.exchange_name}' 不存在: {str(e)} (主机: {self._active_host})")
-            return False
-
-    async def _check_queue_exists(self) -> bool:
-        """检查队列是否存在"""
-        if not self.channel or not self.queue_name:
+            logger.warning(f"检查连接状态失败: {str(e)}")
             return False
 
-        try:
-            # 使用被动模式检查队列是否存在
-            await asyncio.wait_for(
-                self.channel.declare_queue(
-                    name=self.queue_name,
-                    passive=True
-                ),
-                timeout=self.rpc_timeout
+    async def _rebuild_resources(self) -> None:
+        """重建交换机/队列等资源（依赖已有的通道）"""
+        if not self._channel or self._channel.is_closed:
+            raise RuntimeError("无有效通道，无法重建资源")
+
+        # 1. 声明交换机
+        self._exchange = await self._channel.declare_exchange(
+            name=self.exchange_name,
+            type=self.exchange_type,
+            durable=self.durable,
+            auto_delete=self.auto_delete,
+            passive=not self.create_if_not_exists,
+        )
+        logger.info(
+            f"交换机重建成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
+
+        # 2. 声明队列（如果配置了队列名）
+        if self.queue_name:
+            self._queue = await self._channel.declare_queue(
+                name=self.queue_name,
+                durable=self.durable,
+                auto_delete=self.auto_delete,
+                passive=not self.create_if_not_exists,
             )
-            self._queue_exists = True
-            self._update_activity_timestamp()
-            return True
-        except asyncio.TimeoutError:
-            logger.error(
-                f"检查队列 '{self.queue_name}' 超时 (主机: {self._active_host})")
-            return False
-        except Exception as e:
-            logger.debug(
-                f"队列 '{self.queue_name}' 不存在: {str(e)} (主机: {self._active_host})")
-            return False
-
-    async def _bind_queue(self) -> bool:
-        """将队列绑定到交换机"""
-        if not self.channel or not self.queue or not self.exchange:
-            return False
-
-        retries = 2
-        bind_routing_key = self.routing_key if self.routing_key else '#'
-
-        for attempt in range(retries + 1):
-            try:
-                await asyncio.wait_for(
-                    self.queue.bind(
-                        self.exchange,
-                        routing_key=bind_routing_key
-                    ),
-                    timeout=self.rpc_timeout
-                )
-                self._queue_bound = True
-                self._update_activity_timestamp()
-                logger.info(
-                    f"队列 '{self.queue_name}' 已绑定到交换机 '{self.exchange_name}'，路由键: {bind_routing_key} (主机: {self._active_host})")
-                return True
-            except asyncio.TimeoutError:
-                logger.warning(
-                    f"队列 '{self.queue_name}' 绑定超时（第{attempt+1}次尝试）(主机: {self._active_host})")
-            except Exception as e:
-                logger.error(
-                    f"队列绑定失败（第{attempt+1}次尝试）: {str(e)} (主机: {self._active_host})")
-
-            if attempt < retries:
-                await asyncio.sleep(1)
-
-        self._queue_bound = False
-        return False
-
-    async def _try_connect_host(self, host: str) -> AbstractConnection:
-        """尝试连接单个主机"""
-        try:
-            logger.debug(f"尝试连接主机: {host}:{self.port}")
-            return await asyncio.wait_for(
-                connect_robust(
-                    host=host,
-                    port=self.port,
-                    login=self.username,
-                    password=self.password,
-                    virtualhost=self.virtualhost,
-                    heartbeat=self.heartbeat,
-                    loop=asyncio.get_event_loop(),
-                    client_properties={
-                        "connection_name": f"{self.app_name}@{host}"
-                    }
-                ),
-                timeout=self.connection_timeout
+            # 绑定队列到交换机
+            await self._queue.bind(
+                exchange=self._exchange,
+                routing_key=self.routing_key,
+            )
+            logger.info(
+                f"队列重建成功: {self.queue_name} "
+                f"（绑定交换机: {self.exchange_name}, routing_key: {self.routing_key}）"
             )
-        except Exception as e:
-            logger.warning(f"连接主机 {host}:{self.port} 失败: {str(e)}")
-            raise
 
-    async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
-        """
-        建立与RabbitMQ集群的连接（支持多节点故障转移）并初始化所需资源
+    async def connect(self) -> None:
+        if self._closed:
+            raise RuntimeError("客户端已关闭，无法重新连接")
+
+        async with self._connect_lock:
+            # 释放旧资源（回调+通道，单通道无需归还，仅清理状态）
+            if self._conn_close_callback and self._channel_conn:
+                self._channel_conn.close_callbacks.discard(
+                    self._conn_close_callback)
+            self._channel = None
+            self._channel_conn = None
+            self._exchange = None
+            self._queue = None
+            self._conn_close_callback = None
 
-        :param force_reconnect: 是否强制重新连接
-        :param declare_queue: 是否声明队列
-        """
-        logger.debug(
-            f"连接参数 - force_reconnect={force_reconnect}, "
-            f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}, "
-            f"主机列表: {self.hosts}"
-        )
+            try:
+                # 从单通道池获取通道+连接（连接池自动确保通道有效）
+                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
-        # 如果已连接且不强制重连，则直接返回
-        if self.is_connected and not force_reconnect:
-            return
+                def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
+                    """连接关闭回调：触发固定间隔重连"""
+                    logger.warning(
+                        f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
+                    self._reconnect_fail_count += 1
+                    # 超过阈值告警
+                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
+                        logger.error(
+                            f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
+                    if not self._closed:
+                        asyncio.create_task(self._safe_reconnect())
+
+                self._conn_close_callback = on_conn_closed
+                if self._channel_conn:
+                    self._channel_conn.close_callbacks.add(
+                        self._conn_close_callback)
+
+                # 重建交换机/队列资源
+                await self._rebuild_resources()
+
+                # 重连成功，重置失败计数器
+                self._reconnect_fail_count = 0
+                logger.info("客户端连接初始化完成")
+            except Exception as e:
+                logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+                # 清理异常状态
+                if self._conn_close_callback and self._channel_conn:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
+                self._channel = None
+                self._channel_conn = None
+                # 触发重连
+                if not self._closed:
+                    asyncio.create_task(self._safe_reconnect())
+                raise
+
+    async def _safe_reconnect(self):
+        """安全重连：信号量控制并发+固定15秒间隔"""
+        async with self._reconnect_semaphore:
+            # 检查是否已有重连任务在运行
+            if self._current_reconnect_task and not self._current_reconnect_task.done():
+                logger.debug("已有重连任务在运行，跳过重复触发")
+                return
 
-        # 取消正在进行的重连任务
-        if self._reconnect_task and not self._reconnect_task.done():
-            self._reconnect_task.cancel()
+            if self._closed or await self.is_connected:
+                logger.debug("客户端已关闭或已连接，取消重连")
+                return
 
-        logger.debug(
-            f"尝试连接RabbitMQ集群 - 主机数量: {len(self.hosts)}, "
-            f"虚拟主机: {self.virtualhost}, 队列: {self.queue_name}"
-        )
+            # 固定15秒重连间隔
+            logger.info(f"将在{self._RECONNECT_INTERVAL}秒后尝试重连...")
+            await asyncio.sleep(self._RECONNECT_INTERVAL)
 
-        # 重置状态
-        self._exchange_exists = False
-        self._queue_exists = False
-        self._queue_bound = False
-        self._active_host = None
+            if self._closed or await self.is_connected:
+                logger.debug("重连等待期间客户端状态变化，取消重连")
+                return
 
-        retries = 0
-        last_exception = None
+            try:
+                logger.info("开始重连RabbitMQ客户端...")
+                self._current_reconnect_task = asyncio.create_task(
+                    self.connect())
+                await self._current_reconnect_task
+            except Exception as e:
+                logger.warning(f"重连失败: {str(e)}")
+            finally:
+                self._current_reconnect_task = None
 
-        while retries < self.max_reconnection_attempts:
-            # 遍历所有主机尝试连接（故障转移）
-            for host in self.hosts:
+    async def set_message_handler(
+        self,
+        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
+    ) -> None:
+        """设置消息处理器（必须是协程函数）"""
+        if not asyncio.iscoroutinefunction(handler):
+            raise TypeError("消息处理器必须是协程函数（使用 async def 定义）")
+
+        async with self._consume_lock:
+            self._message_handler = handler
+            logger.info("消息处理器设置成功")
+
+    async def start_consuming(self) -> Optional[ConsumerTag]:
+        """启动消息消费（支持自动重连）"""
+        if self._closed:
+            raise RuntimeError("客户端已关闭，无法启动消费")
+
+        async with self._consume_lock:
+            # 1. 校验前置条件
+            if not self._message_handler:
+                raise RuntimeError("未设置消息处理器，请先调用 set_message_handler()")
+            if not await self.is_connected:
+                await self.connect()
+            if not self._queue:
+                raise RuntimeError("未配置队列名或队列未创建，无法启动消费")
+
+            # 2. 定义消费回调（包含异常处理和重连逻辑）
+            async def consume_callback(message: AbstractIncomingMessage):
                 try:
-                    # 关闭现有连接
-                    if self.connection and not self.connection.is_closed:
-                        await self.connection.close()
-
-                    # 尝试连接当前主机
-                    self.connection = await self._try_connect_host(host)
-                    self._active_host = host
-
-                    # 创建通道
-                    self.channel = await asyncio.wait_for(
-                        self.connection.channel(),
-                        timeout=self.rpc_timeout
-                    )
-
-                    # 启用发布确认
-                    # await self.channel.confirm_delivery()
-
-                    # 设置预取计数，控制消息公平分发
-                    await self.channel.set_qos(prefetch_count=self.prefetch_count)
-
-                    # 处理交换机
-                    exchange_exists = await self._check_exchange_exists()
-                    if not exchange_exists:
-                        if self.create_if_not_exists:
-                            # 创建交换机
-                            self.exchange = await asyncio.wait_for(
-                                self.channel.declare_exchange(
-                                    name=self.exchange_name,
-                                    type=self.exchange_type,
-                                    durable=self.durable,
-                                    auto_delete=self.auto_delete
-                                ),
-                                timeout=self.rpc_timeout
-                            )
-                            self._exchange_exists = True
-                            logger.info(
-                                f"已创建交换机 '{self.exchange_name}' (主机: {self._active_host})")
-                        else:
-                            raise Exception(
-                                f"交换机 '{self.exchange_name}' 不存在且不允许自动创建 (主机: {self._active_host})")
+                    # 解析消息体
+                    if self.auto_parse_json:
+                        try:
+                            body_dict = json.loads(
+                                message.body.decode("utf-8"))
+                            msg_obj = MQMsgModel(**body_dict)
+                        except json.JSONDecodeError as e:
+                            logger.error(
+                                f"JSON消息解析失败: {str(e)}，消息体: {message.body[:100]}...")
+                            await message.nack(requeue=False)  # 解析失败，不重入队
+                            return
                     else:
-                        # 获取已有交换机
-                        self.exchange = await asyncio.wait_for(
-                            self.channel.get_exchange(self.exchange_name),
-                            timeout=self.rpc_timeout
+                        msg_obj = MQMsgModel(
+                            body=message.body.decode("utf-8"),
+                            routing_key=message.routing_key,
+                            delivery_tag=message.delivery_tag,
                         )
-                        logger.info(
-                            f"使用已存在的交换机 '{self.exchange_name}' (主机: {self._active_host})")
-
-                    # 处理队列
-                    if declare_queue and self.queue_name:
-                        queue_exists = await self._check_queue_exists()
-
-                        if not queue_exists:
-                            if not self.create_if_not_exists:
-                                raise Exception(
-                                    f"队列 '{self.queue_name}' 不存在且不允许自动创建 (主机: {self._active_host})")
-
-                            # 创建队列
-                            self.queue = await asyncio.wait_for(
-                                self.channel.declare_queue(
-                                    name=self.queue_name,
-                                    durable=self.durable,
-                                    auto_delete=self.auto_delete,
-                                    exclusive=False
-                                ),
-                                timeout=self.rpc_timeout
-                            )
-                            self._queue_exists = True
-                            self.actual_queue_name = self.queue_name
-                            logger.info(
-                                f"已创建队列 '{self.queue_name}' (主机: {self._active_host})")
-                        else:
-                            # 获取已有队列
-                            self.queue = await asyncio.wait_for(
-                                self.channel.get_queue(self.queue_name),
-                                timeout=self.rpc_timeout
-                            )
-                            self.actual_queue_name = self.queue_name
-                            logger.info(
-                                f"使用已存在的队列 '{self.queue_name}' (主机: {self._active_host})")
-
-                        # 绑定队列到交换机
-                        if self.queue and self.exchange:
-                            bound = await self._bind_queue()
-                            if not bound:
-                                raise Exception(
-                                    f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败 (主机: {self._active_host})")
-                        else:
-                            raise Exception(
-                                "队列或交换机未正确初始化 (主机: {self._active_host})")
-                    else:
-                        # 不声明队列时的状态处理
-                        self.queue = None
-                        self.actual_queue_name = None
-                        self._queue_exists = False
-                        self._queue_bound = False
-                        logger.debug(
-                            f"跳过队列 '{self.queue_name}' 的声明和绑定 (主机: {self._active_host})")
-
-                    # 验证连接状态
-                    if not self.is_connected:
-                        raise Exception(
-                            f"连接验证失败，状态异常 (主机: {self._active_host})")
-
-                    # 如果之前在消费，重新开始消费
-                    if self._is_consuming and self.message_handler:
-                        await self.start_consuming()
-
-                    # 启动连接监控和保活任务
-                    self._start_monitoring()
-                    self._start_keepalive()
-
-                    self._update_activity_timestamp()
-                    logger.info(
-                        f"RabbitMQ客户端连接成功 (主机: {self._active_host}, 队列: {self.actual_queue_name})")
-                    return
-
-                except Exception as e:
-                    last_exception = e
-                    logger.warning(
-                        f"主机 {host} 连接处理失败: {str(e)}，尝试下一个主机...")
-                    # 清理当前失败的连接资源
-                    if self.connection and not self.connection.is_closed:
-                        await self.connection.close()
-                    self.connection = None
-                    self.channel = None
-                    self.exchange = None
-                    self.queue = None
-
-            # 所有主机都尝试失败，进行重试
-            retries += 1
-            logger.warning(
-                f"集群连接失败（{retries}/{self.max_reconnection_attempts}），所有主机均无法连接，重试中...")
-
-            if retries < self.max_reconnection_attempts:
-                await asyncio.sleep(self.reconnection_delay)
-
-        logger.error(f"最终连接失败: {str(last_exception)}")
-        raise Exception(
-            f"经过{self.max_reconnection_attempts}次重试后仍无法连接到RabbitMQ集群。最后错误: {str(last_exception)}")
-
-    def _start_monitoring(self) -> None:
-        """启动连接和消费监控任务，支持集群节点故障检测"""
-        if self._closed or (self._monitor_task and not self._monitor_task.done()):
-            return
-
-        async def monitor():
-            while not self._closed and self.connection:
-                try:
-                    # 检查连接状态
-                    if self.connection.is_closed:
-                        logger.warning(
-                            f"检测到RabbitMQ连接已关闭 (主机: {self._active_host})，将尝试重连到集群其他节点")
-                        await self._schedule_reconnect()
-                        return
-
-                    # 检查通道状态
-                    if self.channel and self.channel.is_closed:
-                        logger.warning(
-                            f"检测到RabbitMQ通道已关闭 (主机: {self._active_host})，将尝试重建")
-                        await self._recreate_channel()
-                        continue
-
-                    # 检查消费停滞
-                    if self._is_consuming:
-                        current_time = asyncio.get_event_loop().time()
-                        if current_time - self._last_message_processed > self.consumption_stall_threshold:
-                            # logger.warning(
-                            #     f"检测到消费停滞超过 {self.consumption_stall_threshold} 秒 (主机: {self._active_host})，将重启消费者")
-                            if self._is_consuming and self.message_handler:
-                                await self.stop_consuming()
-                                await asyncio.sleep(1)
-                                await self.start_consuming()
-                                # logger.info("消费者已重启以恢复消费")
-                except Exception as e:
-                    logger.error(f"监控任务出错: {str(e)}")
-                    await asyncio.sleep(1)
-
-                await asyncio.sleep(5)  # 每5秒检查一次
-
-        self._monitor_task = asyncio.create_task(monitor())
-
-    async def _recreate_channel(self) -> None:
-        """重建通道并恢复绑定和消费，支持当前节点故障时的快速恢复"""
-        try:
-            # 连接已关闭时触发完整重连（尝试其他节点）
-            if not self.connection or self.connection.is_closed:
-                logger.warning("连接已关闭，触发集群重连")
-                await self._schedule_reconnect()
-                return
-
-            # 重新创建通道
-            self.channel = await self.connection.channel()
-            await self.channel.set_qos(prefetch_count=self.prefetch_count)
-
-            # 重新获取交换机
-            self.exchange = await self.channel.get_exchange(self.exchange_name)
 
-            # 重新绑定队列和交换机
-            if self.queue_name:
-                self.queue = await self.channel.get_queue(self.queue_name)
-                if self.queue and self.exchange:
-                    await self._bind_queue()
+                    # 调用消息处理器
+                    await self._message_handler(msg_obj, message)
 
-            # 重新开始消费
-            if self._is_consuming and self.message_handler:
-                await self.start_consuming()
-
-            logger.info(f"通道已重新创建并恢复服务 (主机: {self._active_host})")
-            self._update_activity_timestamp()
-        except Exception as e:
-            logger.error(f"通道重建失败，触发集群重连: {str(e)} (主机: {self._active_host})")
-            await self._schedule_reconnect()
-
-    def _start_keepalive(self) -> None:
-        """启动连接保活任务，维护集群连接心跳"""
-        if self._closed or (self._keepalive_task and not self._keepalive_task.done()):
-            return
-
-        async def keepalive():
-            while not self._closed and self.is_connected:
-                current_time = asyncio.get_event_loop().time()
-                # 检查是否超过指定时间无活动
-                if current_time - self._last_activity_timestamp > self.heartbeat * 1.5:
+                    # 手动ACK
+                    await message.ack()
                     logger.debug(
-                        f"连接 {self.heartbeat*1.5}s 无活动，执行保活检查 (主机: {self._active_host})")
-                    try:
-                        if self.connection and self.connection.is_closed:
-                            logger.warning("连接已关闭，触发集群重连")
-                            await self._schedule_reconnect()
-                            return
+                        f"消息处理成功，delivery_tag: {message.delivery_tag}")
 
-                        # 执行轻量级操作保持连接活跃
-                        if self.channel:
-                            await asyncio.wait_for(
-                                self.channel.declare_exchange(
-                                    name=self.exchange_name,
-                                    type=self.exchange_type,
-                                    passive=True  # 仅检查存在性
-                                ),
-                                timeout=5
-                            )
-
-                        self._update_activity_timestamp()
-                    except asyncio.TimeoutError:
-                        logger.warning(
-                            f"保活检查超时，触发集群重连 (主机: {self._active_host})")
-                        await self._schedule_reconnect()
-                    except Exception as e:
+                except Exception as e:
+                    logger.error(
+                        f"消息处理失败，delivery_tag: {message.delivery_tag}",
+                        exc_info=True
+                    )
+                    # 处理失败逻辑：首次失败重入队，再次失败丢弃
+                    if message.redelivered:
                         logger.warning(
-                            f"保活检查失败: {str(e)}，触发集群重连 (主机: {self._active_host})")
-                        await self._schedule_reconnect()
-
-                await asyncio.sleep(self.heartbeat / 2)  # 每心跳间隔的一半检查一次
-
-        self._keepalive_task = asyncio.create_task(keepalive())
-
-    async def _schedule_reconnect(self) -> None:
-        """安排重新连接（尝试集群中的所有节点）"""
-        if self._reconnect_task and not self._reconnect_task.done():
-            return
-
-        logger.info(f"将在 {self.reconnection_delay} 秒后尝试重新连接到RabbitMQ集群...")
-
-        async def reconnect():
-            try:
-                await asyncio.sleep(self.reconnection_delay)
-                if not self._closed:
-                    # 重连时尝试所有节点
-                    await self.connect(force_reconnect=True)
-            except Exception as e:
-                logger.error(f"重连任务失败: {str(e)}")
-                if not self._closed:
-                    await self._schedule_reconnect()
-
-        self._reconnect_task = asyncio.create_task(reconnect())
+                            f"消息已重入队过，本次拒绝入队: {message.delivery_tag}")
+                        await message.reject(requeue=False)
+                    else:
+                        logger.warning(f"消息重入队: {message.delivery_tag}")
+                        await message.nack(requeue=True)
 
-    async def close(self) -> None:
-        """关闭连接并清理资源"""
-        self._closed = True
-        self._is_consuming = False
+                    # 连接失效则触发重连
+                    if not await self.is_connected:
+                        logger.warning("连接已失效，触发客户端重连")
+                        asyncio.create_task(self._safe_reconnect())
 
-        # 取消所有任务
-        for task in [self._keepalive_task, self._reconnect_task,
-                     self._consuming_task, self._monitor_task]:
-            if task and not task.done():
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
+            # 3. 启动消费（单通道消费，避免阻塞发布需确保业务回调非阻塞）
+            self._consumer_tag = await self._queue.consume(consume_callback)
+            logger.info(
+                f"开始消费队列: {self._queue.name}，consumer_tag: {self._consumer_tag}"
+            )
+            return self._consumer_tag
 
-        # 关闭连接
-        if self.connection and not self.connection.is_closed:
+    async def stop_consuming(self) -> None:
+        """停止消息消费（适配 RobustChannel）"""
+        async with self._consume_lock:
             try:
-                await asyncio.wait_for(self.connection.close(), timeout=5)
+                # 校验核心条件：消费标签、队列、通道均有效
+                if self._consumer_tag and self._queue and self._channel and not self._channel.is_closed:
+                    # 使用队列的 cancel 方法（适配 RobustChannel）
+                    await self._queue.cancel(self._consumer_tag)
+                    logger.info(
+                        f"停止消费成功，consumer_tag: {self._consumer_tag}，队列: {self._queue.name}"
+                    )
+                elif self._consumer_tag:
+                    # 部分资源无效时的日志提示
+                    if not self._queue:
+                        logger.warning(
+                            f"消费标签存在但队列为空，无法取消消费（consumer_tag: {self._consumer_tag}）")
+                    elif not self._channel or self._channel.is_closed:
+                        logger.warning(
+                            f"通道已关闭，消费已自动停止（consumer_tag: {self._consumer_tag}，队列: {self._queue.name if self._queue else '未知'}）"
+                        )
             except Exception as e:
-                logger.warning(f"关闭连接时出错 (主机: {self._active_host}): {str(e)}")
-
-        # 重置状态
-        self.connection = None
-        self.channel = None
-        self.exchange = None
-        self.queue = None
-        self._exchange_exists = False
-        self._queue_exists = False
-        self._queue_bound = False
-        self._consumer_tag = None
-        self._processing_message_ids.clear()
-        self._active_host = None
-
-        logger.info("RabbitMQ客户端已关闭")
+                logger.error(
+                    f"停止消费者 '{self._queue.name if self._queue else '未知队列'}' 时出错: {str(e)}", exc_info=True
+                )
+            finally:
+                self._consumer_tag = None  # 无论成败，清理消费标签
 
     async def publish(
         self,
-        message_body: Union[str, Dict[str, Any]],
-        routing_key: Optional[str] = None,
-        content_type: str = "application/json",
+        message_body: Union[str, Dict[str, Any], MQMsgModel],
         headers: Optional[Dict[str, Any]] = None,
-        delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT
+        content_type: str = "application/json",
+        delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT,
+        retry_count: int = 3,
     ) -> None:
         """
-        发布消息到交换机（自动处理连接故障并重试）
-
-        :param message_body: 消息体，可以是字符串或字典
-        :param routing_key: 路由键，如未指定则使用实例的routing_key
-        :param content_type: 内容类型
-        :param headers: 消息头
-        :param delivery_mode: 投递模式，持久化或非持久化
+        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
+        :param message_body: 消息体（字符串/字典/MQMsgModel）
+        :param headers: 消息头（可选）
+        :param content_type: 内容类型（默认application/json）
+        :param delivery_mode: 投递模式（PERSISTENT=持久化，TRANSIENT=非持久化）
+        :param retry_count: 重试次数（默认3次）
         """
-        if not self.is_connected:
-            logger.warning("连接已关闭，尝试重连后发布消息")
-            await self.connect(force_reconnect=True)
-
-        if not self.channel or not self.exchange:
-            raise Exception("RabbitMQ连接未初始化")
-
-        # 处理消息体
-        if isinstance(message_body, dict):
-            message_body_str = json.dumps(message_body, ensure_ascii=False)
-            if content_type == "text/plain":
-                content_type = "application/json"
-        else:
-            message_body_str = str(message_body)
-
-        # 创建消息对象
+        if self._closed:
+            raise RuntimeError("客户端已关闭，无法发布消息")
+
+        # 处理消息体序列化
+        try:
+            if isinstance(message_body, MQMsgModel):
+                body = json.dumps(message_body.to_dict(),
+                                  ensure_ascii=False).encode("utf-8")
+            elif isinstance(message_body, dict):
+                body = json.dumps(
+                    message_body, ensure_ascii=False).encode("utf-8")
+            elif isinstance(message_body, str):
+                body = message_body.encode("utf-8")
+            else:
+                raise TypeError(f"不支持的消息体类型: {type(message_body)}")
+        except Exception as e:
+            logger.error(f"消息体序列化失败: {str(e)}", exc_info=True)
+            raise
+
+        # 构建消息对象
         message = Message(
-            body=message_body_str.encode(),
-            content_type=content_type,
+            body=body,
             headers=headers or {},
-            delivery_mode=delivery_mode
+            content_type=content_type,
+            delivery_mode=delivery_mode,
         )
 
-        # 发布消息（带重试机制）
-        retry_count = 0
-        while retry_count < 2:  # 最多重试2次
+        # 发布重试逻辑
+        for retry in range(retry_count):
             try:
-                await self.exchange.publish(
-                    message,
-                    routing_key=routing_key or self.routing_key or '#',
+                # 确保连接有效
+                if not await self.is_connected:
+                    logger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
+                    await self.connect()
+
+                # 核心：发布消息（mandatory=True 确保路由有效，timeout=5s 避免阻塞）
+                publish_result = await self._exchange.publish(
+                    message=message,
+                    routing_key=self.routing_key or self.queue_name or "#",
                     mandatory=True,
                     timeout=5.0
                 )
-                self._update_activity_timestamp()
-                logger.debug(
-                    f"消息已发布到交换机 '{self.exchange_name}' (主机: {self._active_host})")
-                return
-            except (ConnectionClosed, ChannelInvalidStateError):
-                retry_count += 1
-                logger.warning(f"连接已关闭，尝试重连后重新发布 (重试次数: {retry_count})")
-                await self.connect(force_reconnect=True)
-            except Exception as e:
-                retry_count += 1
-                logger.error(f"消息发布失败 (重试次数: {retry_count}): {str(e)}")
-                if retry_count < 2:
-                    await asyncio.sleep(1)
-
-        raise Exception(f"消息发布失败，经过{retry_count}次重试仍未成功")
-
-    def set_message_handler(
-        self,
-        handler: Callable[
-            [Union[Dict[str, Any], str], AbstractIncomingMessage],
-            Coroutine[Any, Any, None]
-        ]
-    ) -> None:
-        """
-        设置消息处理函数
 
-        :param handler: 消息处理函数，接收解析后的消息和原始消息对象
-        """
-        self.message_handler = handler
-
-    async def start_consuming(self) -> ConsumerTag:
-        """
-        开始消费消息
-
-        :return: 消费者标签
-        """
-        if self._is_consuming:
-            logger.debug("已经在消费中，返回现有consumer_tag")
-            if self._consumer_tag:
-                return self._consumer_tag
-            raise Exception("消费已启动但未获取到consumer_tag")
-
-        # 确保连接和队列已准备好
-        if not self.is_connected:
-            await self.connect()
-
-        if not self.queue:
-            raise Exception("队列未初始化，无法开始消费")
-
-        if not self.message_handler:
-            raise Exception("未设置消息处理函数")
-
-        self._is_consuming = True
-        logger.info(
-            f"开始消费队列: {self.actual_queue_name} (主机: {self._active_host})")
-
-        try:
-            # 开始消费，使用aio-pika的队列消费方法
-            self._consumer_tag = await self.queue.consume(
-                self._message_wrapper,
-                no_ack=False  # 手动确认消息
-            )
-
-            logger.info(
-                f"消费者已启动，队列: {self.actual_queue_name}, tag: {self._consumer_tag}, 主机: {self._active_host}")
-            return self._consumer_tag
-        except Exception as e:
-            self._is_consuming = False
-            logger.error(
-                f"启动消费失败: {str(e)} (主机: {self._active_host})", exc_info=True)
-            raise
-
-    async def _safe_cancel_consumer(self) -> bool:
-        """安全取消消费者"""
-        if not self._consumer_tag or not self.queue or not self.channel:
-            return True
-
-        try:
-            await asyncio.wait_for(
-                self.queue.cancel(self._consumer_tag),
-                timeout=self.rpc_timeout
-            )
-            logger.info(
-                f"消费者 {self._consumer_tag} 已取消 (主机: {self._active_host})")
-            return True
-        except (ChannelInvalidStateError, ConnectionClosed):
-            logger.warning(f"取消消费者失败：通道或连接已关闭 (主机: {self._active_host})")
-            return False
-        except asyncio.TimeoutError:
-            logger.warning(f"取消消费者超时 (主机: {self._active_host})")
-            return False
-        except Exception as e:
-            logger.error(f"取消消费者异常: {str(e)} (主机: {self._active_host})")
-            return False
-
-    async def stop_consuming(self) -> None:
-        """停止消费消息，等待正在处理的消息完成"""
-        if not self._is_consuming:
-            return
-
-        self._is_consuming = False
-
-        # 取消消费者，停止接收新消息
-        if self._consumer_tag and self.queue:
-            await self._safe_cancel_consumer()
-
-        # 等待所有正在处理的消息完成
-        if self._processing_message_ids:
-            logger.info(
-                f"等待 {len(self._processing_message_ids)} 个正在处理的消息完成... (主机: {self._active_host})"
-            )
-            # 循环等待直到所有消息处理完成
-            while self._processing_message_ids and not self._closed:
-                await asyncio.sleep(0.1)
-
-        # 清理状态
-        self._consumer_tag = None
-        self._processing_message_ids.clear()
-
-        logger.info(
-            f"已停止消费队列: {self.actual_queue_name} (主机: {self._active_host})")
-
-    async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
-        """解析消息体"""
-        try:
-            body_str = message.body.decode('utf-8')
-            self._update_activity_timestamp()
-
-            if self.auto_parse_json:
-                return json.loads(body_str)
-            return body_str
-        except json.JSONDecodeError:
-            logger.warning(f"消息解析JSON失败，返回原始字符串 (主机: {self._active_host})")
-            return body_str
-        except Exception as e:
-            logger.error(f"消息解析出错: {str(e)} (主机: {self._active_host})")
-            return message.body.decode('utf-8')
-
-    async def _message_wrapper(self, message: AbstractIncomingMessage) -> None:
-        """消息处理包装器，处理消息接收、解析、分发和确认"""
-        if not self.message_handler or not self._is_consuming:
-            logger.warning("未设置消息处理器或已停止消费，确认消息")
-            await message.ack()
-            return
-
-        # 跟踪消息ID，防止重复处理
-        message_id = message.message_id or str(id(message))
-        if message_id in self._processing_message_ids:
-            logger.warning(
-                f"检测到重复处理的消息ID: {message_id}，直接确认 (主机: {self._active_host})")
-            await message.ack()
-            return
-
-        self._processing_message_ids.add(message_id)
-
-        try:
-            logger.debug(
-                f"收到队列 {self.actual_queue_name} 的消息: {message_id} (主机: {self._active_host})")
-
-            # 解析消息
-            parsed_data = await self._parse_message(message)
-
-            await self.message_handler(MQMsgModel(**parsed_data), message)
-
-            # 处理成功，确认消息
-            await message.ack()
-            self._update_activity_timestamp()
-            self._update_message_processed_timestamp()
-            logger.debug(f"消息 {message_id} 处理完成并确认 (主机: {self._active_host})")
-
-        except Exception as e:
-            # 处理失败，根据重试次数决定是否重新发布
-            current_headers = message.headers or {}
-            retry_count = current_headers.get('x-retry-count', 0)
-            retry_count += 1
-
-            logger.error(
-                f"消息 {message_id} 处理出错（第{retry_count}次重试）: {str(e)} (主机: {self._active_host})",
-                exc_info=True
-            )
+                # 处理 mandatory 未路由场景
+                if publish_result is None:
+                    raise RuntimeError(
+                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
+                    )
 
-            if retry_count >= MAX_RETRY_COUNT:
-                logger.error(
-                    f"消息 {message_id} 已达到最大重试次数({MAX_RETRY_COUNT}次)，标记为失败 (主机: {self._active_host})")
-                await message.ack()
-                self._update_activity_timestamp()
+                logger.info(
+                    f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
+                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
+                )
                 return
+            except asyncio.TimeoutError:
+                logger.error(
+                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
+                )
+            except RuntimeError as e:
+                logger.error(
+                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
+                )
+            except Exception as e:
+                logger.error(
+                    f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
+                    exc_info=True
+                )
+                # 清理失效状态，下次重试重连
+                self._exchange = None
+            # 指数退避重试间隔
+            await asyncio.sleep(0.5 * (2 ** retry))
+
+        # 所有重试失败
+        raise RuntimeError(
+            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
+            f"mandatory: True，timeout: 5.0s"
+        )
 
-            # 准备重新发布的消息
-            new_headers = current_headers.copy()
-            new_headers['x-retry-count'] = retry_count
-
-            new_message = Message(
-                body=message.body,
-                content_type=message.content_type,
-                headers=new_headers,
-                delivery_mode=message.delivery_mode
-            )
-
-            # 拒绝原消息（不重新入队）
-            await message.reject(requeue=False)
+    async def close(self) -> None:
+        """关闭客户端（移除回调+释放资源）"""
+        self._closed = True
+        logger.info("开始关闭RabbitMQ客户端...")
 
-            # 重新发布消息
-            if self.exchange:
-                await self.exchange.publish(
-                    new_message,
-                    routing_key=self.routing_key or '#',
-                    mandatory=True,
-                    timeout=5.0
-                )
-                self._update_activity_timestamp()
-                logger.info(
-                    f"消息 {message_id} 已重新发布，当前重试次数: {retry_count} (主机: {self._active_host})")
-        finally:
-            # 移除消息ID跟踪
-            if message_id in self._processing_message_ids:
-                self._processing_message_ids.remove(message_id)
-
-    async def __aenter__(self):
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb):
-        await self.close()
+        # 停止重连任务
+        if self._current_reconnect_task and not self._current_reconnect_task.done():
+            self._current_reconnect_task.cancel()
+            try:
+                await self._current_reconnect_task
+            except asyncio.CancelledError:
+                logger.debug("重连任务已取消")
+
+        # 1. 停止消费
+        await self.stop_consuming()
+
+        # 2. 清理回调+状态（单通道无需归还，连接池统一管理）
+        async with self._connect_lock:
+            if self._conn_close_callback and self._channel_conn:
+                self._channel_conn.close_callbacks.discard(
+                    self._conn_close_callback)
+            self._channel = None
+            self._channel_conn = None
+            self._exchange = None
+            self._queue = None
+            self._message_handler = None
+
+        logger.info("RabbitMQ客户端已完全关闭")