sycommon-python-lib 0.1.46__py3-none-any.whl → 0.1.57b1__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -1,9 +1,7 @@
-from aio_pika import Channel
-from typing import Optional
 import asyncio
 import json
-from typing import Callable, Coroutine, Dict, Any, Union
-from aio_pika import Message, DeliveryMode, ExchangeType
+from typing import Optional, Callable, Coroutine, Dict, Any, Union
+from aio_pika import Channel, Message, DeliveryMode, ExchangeType
 from aio_pika.abc import (
     AbstractExchange,
     AbstractQueue,
@@ -15,19 +13,12 @@ from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
-
 logger = SYLogger
 
 
 class RabbitMQClient:
     """
-    RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
-    核心特性：
-    1. 基于连接池复用资源，性能优化
-    2. 连接/通道失效时自动重建，高可用（限制并发重连）
-    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
-    4. 消费支持手动ACK/NACK
-    5. 兼容JSON/字符串/字典消息格式
+    RabbitMQ 客户端
     """
 
     def __init__(
@@ -36,41 +27,36 @@ class RabbitMQClient:
         exchange_name: str = "system.topic.exchange",
         exchange_type: str = "topic",
         queue_name: Optional[str] = None,
+        app_name: Optional[str] = None,
         routing_key: str = "#",
         durable: bool = True,
         auto_delete: bool = False,
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
-        prefetch_count: int = 2,
         **kwargs,
     ):
-        # 依赖注入：连接池（必须已初始化）
         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:
-            SYLogger.warning(f"无效的exchange_type: {exchange_type}，默认使用'topic'")
-            self.exchange_type = ExchangeType.topic
+            logger.warning(f"无效的exchange_type: {exchange_type}，默认使用'topic'")
+            self.exchange_type = ExchangeType.TOPIC
 
-        # 队列配置
+        self.app_name = app_name.strip() if app_name else None
         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.prefetch_count = max(1, prefetch_count)  # 每次预取消息数（避免消息堆积）
+        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._channel: Optional[Channel] = None
-        self._channel_conn: Optional[AbstractRobustConnection] = None  # 通道所属连接
+        self._channel_conn: Optional[AbstractRobustConnection] = None
         self._exchange: Optional[AbstractExchange] = None
         self._queue: Optional[AbstractQueue] = None
         self._consumer_tag: Optional[ConsumerTag] = None
@@ -78,266 +64,296 @@ class RabbitMQClient:
             MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = None
         self._closed = False
 
-        # 线程安全锁
+        # 并发控制
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
-        # 跟踪连接关闭回调（用于后续移除）
+
+        # 防止并发重连覆盖
+        self._connecting = False
+        self._connect_condition = asyncio.Condition()
+
         self._conn_close_callback: Optional[Callable] = None
-        # 控制重连频率的信号量（限制并发重连数，默认1个）
         self._reconnect_semaphore = asyncio.Semaphore(1)
-        # 固定重连间隔15秒（全局统一）
-        self._RECONNECT_INTERVAL = 15
-        # 重连任务锁（确保同一时间只有一个重连任务）
-        self._reconnect_task_lock = asyncio.Lock()
-        # 跟踪当前重连任务（避免重复创建）
         self._current_reconnect_task: Optional[asyncio.Task] = None
-        # 连接失败计数器（用于告警）
-        self._reconnect_fail_count = 0
-        # 连接失败告警阈值
-        self._reconnect_alert_threshold = 5
+        self._RECONNECT_INTERVAL = 15
 
     @property
     async def is_connected(self) -> bool:
-        """异步检查客户端连接状态（属性，不可调用）"""
         if self._closed:
             return False
         try:
-            # 校验通道+连接+核心资源都有效
             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)
             )
-        except Exception as e:
-            SYLogger.warning(f"检查连接状态失败: {str(e)}")
+        except Exception:
             return False
 
+    async def _rebuild_resources(self) -> None:
+        if not self._channel or self._channel.is_closed:
+            raise RuntimeError("无有效通道，无法重建资源")
+
+        # 声明交换机
+        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}")
+
+        # 声明队列
+        if self.queue_name and self.queue_name.endswith(f".{self.app_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,
+            )
+            await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+            logger.info(f"队列重建成功: {self.queue_name}")
+
     async def connect(self) -> None:
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
+        # 1. 并发控制：使用 _connect_lock 保证只有一个协程在执行连接流程
         async with self._connect_lock:
-            # 释放旧资源（保留原有回调清理逻辑）
-            if self._channel and self._channel_conn:
+            # 如果已经在连了，等待其完成
+            if self._connecting:
+                logger.debug("连接正在进行中，等待现有连接完成...")
                 try:
-                    if self._conn_close_callback and self._channel_conn:
+                    # 等待条件变量，超时设为 60 秒防止死等
+                    await asyncio.wait_for(
+                        self._connect_condition.wait_for(
+                            lambda: not self._connecting),
+                        timeout=60.0
+                    )
+                except asyncio.TimeoutError:
+                    raise RuntimeError("等待连接超时")
+
+                # 等待结束后，再次检查状态
+                if not await self.is_connected:
+                    raise RuntimeError("等待重连后，连接状态依然无效")
+                return
+
+            # 标记开始连接
+            self._connecting = True
+
+        # 释放 _connect_lock，允许其他协程读取状态，但在连接完成前阻止新的连接请求
+        # 注意：这里释放了 _connect_lock，但 self._connecting = True 阻止了新的连接流程
+
+        try:
+            # --- 阶段1: 清理旧资源 ---
+            # 重新获取锁进行资源清理
+            async with self._connect_lock:
+                was_consuming = self._consumer_tag is not None
+
+                if self._channel_conn and self._conn_close_callback:
+                    try:
                         self._channel_conn.close_callbacks.discard(
                             self._conn_close_callback)
-                    await self.connection_pool.release_channel(self._channel, self._channel_conn)
-                except Exception as e:
-                    SYLogger.warning(f"释放旧通道失败: {str(e)}")
-            self._channel = None
-            self._channel_conn = None
-            self._exchange = None
-            self._queue = None
-            self._conn_close_callback = None
+                    except Exception:
+                        pass
 
-            try:
-                # 从连接池获取通道+连接（连接池返回的是 RobustChannel）
-                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
-
-                def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
-                    """连接关闭回调：触发固定间隔重连"""
-                    SYLogger.warning(
-                        f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
-                    self._reconnect_fail_count += 1
-                    # 超过阈值告警
-                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
-                        SYLogger.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)
+                self._channel = None
+                self._channel_conn = None
+                self._exchange = None
+                self._queue = None
+                self._conn_close_callback = None
 
-                # 2. 设置预取计数（限流）
-                await self._channel.set_qos(prefetch_count=self.prefetch_count)
-                SYLogger.debug(f"设置预取计数: {self.prefetch_count}")
-
-                # 3. 低版本 RobustChannel 说明：默认启用异步发布确认，无显式确认方法
-                SYLogger.debug(
-                    "基于 RobustChannel 异步发布确认（低版本 aio-pika 不支持显式确认方法）")
-
-                # 4. 声明交换机
-                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,  # passive=True时，不存在则报错
-                )
-                SYLogger.info(
-                    f"交换机初始化成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
+            # --- 阶段2: 获取新连接 (耗时IO) ---
+            self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+
+            # 设置回调
+            def on_conn_closed(conn, exc):
+                logger.warning(f"检测到连接关闭: {exc}")
+                if not self._closed and not self._connecting:
+                    asyncio.create_task(self._safe_reconnect())
 
-                # 5. 声明队列（如果配置了队列名）
-                if self.queue_name:
+            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()
+
+            # --- 阶段3: 恢复消费 ---
+            if was_consuming and self._message_handler and self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
+                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复...")
+                try:
                     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,
-                    )
-                    # 绑定队列到交换机
-                    await self._queue.bind(
-                        exchange=self._exchange,
-                        routing_key=self.routing_key,
-                    )
-                    SYLogger.info(
-                        f"队列初始化成功: {self.queue_name} "
-                        f"（绑定交换机: {self.exchange_name}, routing_key: {self.routing_key}）"
+                        passive=False,
                     )
+                    await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                    self._consumer_tag = await self._queue.consume(self._process_message_callback)
+                    logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                except Exception as e:
+                    logger.error(f"❌ 自动恢复消费失败: {e}")
+                    self._consumer_tag = None
+            else:
+                self._consumer_tag = None
 
-                # 重连成功，重置失败计数器
-                self._reconnect_fail_count = 0
-                SYLogger.info("客户端连接初始化完成")
-            except Exception as e:
-                SYLogger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-                # 清理异常状态
-                if self._conn_close_callback and self._channel_conn:
+            logger.info("客户端连接初始化完成")
+
+        except Exception as e:
+            logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+
+            # 异常时清理资源
+            async with self._connect_lock:
+                if self._channel_conn and self._conn_close_callback:
                     self._channel_conn.close_callbacks.discard(
                         self._conn_close_callback)
-                if self._channel and self._channel_conn:
-                    try:
-                        await self.connection_pool.release_channel(self._channel, self._channel_conn)
-                    except:
-                        pass
                 self._channel = None
                 self._channel_conn = None
-                # 触发重连（固定间隔）
-                if not self._closed:
-                    asyncio.create_task(self._safe_reconnect())
-                raise
+                self._consumer_tag = None
+
+            raise
+
+        finally:
+            # 【关键修复】必须在持有 Condition 内部锁的情况下调用 notify_all
+            # 这里使用 async with self._connect_condition: 自动完成 acquire() ... notify_all() ... release()
+            async with self._connect_condition:
+                self._connecting = False
+                self._connect_condition.notify_all()
 
     async def _safe_reconnect(self):
-        """安全重连：信号量控制并发+固定15秒间隔，避免短时间大量重连"""
-        # 1. 信号量控制：限制同时进行的重连任务数（默认1个）
+        """安全重连任务（仅用于被动监听连接关闭）"""
         async with self._reconnect_semaphore:
-            # 2. 检查是否已有重连任务在运行（双重保障）
-            if self._current_reconnect_task and not self._current_reconnect_task.done():
-                SYLogger.debug("已有重连任务在运行，跳过重复触发")
+            if self._closed:
                 return
 
-            async with self._reconnect_task_lock:
-                if self._closed or await self.is_connected:
-                    SYLogger.debug("客户端已关闭或已连接，取消重连")
-                    return
+            # 如果已经在重连，直接忽略
+            if self._connecting:
+                return
 
-                # 3. 固定15秒重连间隔（避免频繁重试）
-                SYLogger.info(f"将在15秒后尝试重连...")
-                await asyncio.sleep(self._RECONNECT_INTERVAL)
+            logger.info(f"将在{self._RECONNECT_INTERVAL}秒后尝试重连...")
+            await asyncio.sleep(self._RECONNECT_INTERVAL)
 
-                if self._closed or await self.is_connected:
-                    SYLogger.debug("重连等待期间客户端状态变化，取消重连")
-                    return
+            if self._closed or await self.is_connected:
+                return
 
-                try:
-                    # 4. 执行重连
-                    SYLogger.info("开始重连RabbitMQ客户端...")
-                    self._current_reconnect_task = asyncio.create_task(
-                        self.connect())
-                    await self._current_reconnect_task
-                except Exception as e:
-                    SYLogger.warning(f"重连失败: {str(e)}")
-                    # 重连失败后，不主动触发下一次（等待连接关闭回调再次触发，避免死循环）
-                finally:
-                    self._current_reconnect_task = None
+            try:
+                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
 
-    async def set_message_handler(
-        self,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
-    ) -> None:
-        """设置消息处理器（必须是协程函数）"""
+    async def set_message_handler(self, handler: Callable[..., Coroutine]) -> None:
         if not asyncio.iscoroutinefunction(handler):
-            raise TypeError("消息处理器必须是协程函数（使用 async def 定义）")
-
+            raise TypeError("消息处理器必须是协程函数")
         async with self._consume_lock:
             self._message_handler = handler
-            SYLogger.info("消息处理器设置成功")
+
+    async def _process_message_callback(self, message: AbstractIncomingMessage):
+        try:
+            msg_obj: MQMsgModel
+            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解析失败: {e}")
+                    await message.nack(requeue=False)
+                    return
+            else:
+                msg_obj = MQMsgModel(
+                    body=message.body.decode("utf-8"),
+                    routing_key=message.routing_key,
+                    delivery_tag=message.delivery_tag,
+                    traceId=message.headers.get("trace-id"),
+                )
+
+            SYLogger.set_trace_id(msg_obj.traceId)
+
+            if self._message_handler:
+                await self._message_handler(msg_obj, message)
+
+            await message.ack()
+
+        except Exception as e:
+            logger.error(f"消息处理异常: {e}", exc_info=True)
+            headers = dict(message.headers) if message.headers else {}
+            current_retry = int(headers.get("x-retry-count", 0))
+
+            if current_retry >= 3:
+                logger.warning(f"重试次数超限，丢弃消息: {message.delivery_tag}")
+                await message.reject(requeue=False)
+            else:
+                headers["x-retry-count"] = current_retry + 1
+                try:
+                    new_msg = Message(
+                        body=message.body,
+                        headers=headers,
+                        content_type=message.content_type,
+                        delivery_mode=message.delivery_mode
+                    )
+                    # 这里的 publish 如果失败，会触发重连机制
+                    # 但注意，当前是在回调线程中，建议做好异常捕获
+                    await self._exchange.publish(new_msg, routing_key=message.routing_key)
+                    await message.ack()
+                except Exception as pub_err:
+                    logger.error(f"重试发布失败: {pub_err}")
+                    await message.reject(requeue=False)
 
     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()")
+                raise RuntimeError("未设置消息处理器")
+
             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.auto_parse_json:
-                        try:
-                            body_dict = json.loads(
-                                message.body.decode("utf-8"))
-                            msg_obj = MQMsgModel(**body_dict)
-                        except json.JSONDecodeError as e:
-                            SYLogger.error(
-                                f"JSON消息解析失败: {str(e)}，消息体: {message.body[:100]}...")
-                            await message.nack(requeue=False)  # 解析失败，不重入队
-                            return
-                    else:
-                        msg_obj = MQMsgModel(
-                            body=message.body.decode("utf-8"),
-                            routing_key=message.routing_key,
-                            delivery_tag=message.delivery_tag,
-                        )
-
-                    # 调用消息处理器（必须await，避免协程未等待警告）
-                    await self._message_handler(msg_obj, message)
-
-                    # 手动ACK（消息处理成功）
-                    await message.ack()
-                    SYLogger.debug(
-                        f"消息处理成功，delivery_tag: {message.delivery_tag}")
-
-                except Exception as e:
-                    SYLogger.error(
-                        f"消息处理失败，delivery_tag: {message.delivery_tag}",
-                        exc_info=True
+            if not self._queue:
+                if self.queue_name and self.queue_name.endswith(f".{self.app_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,
                     )
-                    # 处理失败逻辑：首次失败重入队，再次失败丢弃
-                    if message.redelivered:
-                        SYLogger.warning(
-                            f"消息已重入队过，本次拒绝入队: {message.delivery_tag}")
-                        await message.reject(requeue=False)
-                    else:
-                        SYLogger.warning(f"消息重入队: {message.delivery_tag}")
-                        await message.nack(requeue=True)
-
-                    # 检查连接状态，失效则触发重连
-                    if not await self.is_connected:
-                        SYLogger.warning("连接已失效，触发客户端重连")
-                        asyncio.create_task(self._safe_reconnect())
-
-            # 3. 启动消费
-            self._consumer_tag = await self._queue.consume(consume_callback)
-            SYLogger.info(
-                f"开始消费队列: {self._queue.name}，consumer_tag: {self._consumer_tag}"
-            )
+                    await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                else:
+                    raise RuntimeError("未配置队列名")
+
+            self._consumer_tag = await self._queue.consume(self._process_message_callback)
+            logger.info(
+                f"开始消费队列: {self._queue.name}，tag: {self._consumer_tag}")
             return self._consumer_tag
 
     async def stop_consuming(self) -> None:
-        """停止消息消费"""
         async with self._consume_lock:
-            if self._consumer_tag and self._queue and not self._queue.is_closed:
+            if self._consumer_tag and self._queue and self._channel:
                 try:
                     await self._queue.cancel(self._consumer_tag)
-                    SYLogger.info(f"停止消费成功，consumer_tag: {self._consumer_tag}")
+                    logger.info(f"停止消费成功: {self._consumer_tag}")
                 except Exception as e:
-                    SYLogger.error(f"停止消费失败: {str(e)}", exc_info=True)
-                finally:
-                    self._consumer_tag = None
+                    logger.warning(f"停止消费异常: {e}")
+            self._consumer_tag = None
+
+    async def _handle_publish_failure(self):
+        try:
+            logger.info("检测到发布异常，强制连接池切换节点...")
+            await self.connection_pool.force_reconnect()
+            # 连接池切换后，必须刷新客户端资源
+            await self.connect()
+            logger.info("故障转移完成，资源已刷新")
+        except Exception as e:
+            logger.error(f"故障转移失败: {e}")
+            raise
 
     async def publish(
         self,
@@ -347,18 +363,9 @@ class RabbitMQClient:
         delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT,
         retry_count: int = 3,
     ) -> None:
-        """
-        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
-        :param message_body: 消息体（字符串/字典/MQMsgModel）
-        :param headers: 消息头（可选）
-        :param content_type: 内容类型（默认application/json）
-        :param delivery_mode: 投递模式（PERSISTENT=持久化，TRANSIENT=非持久化）
-        :param retry_count: 重试次数（默认3次）
-        """
         if self._closed:
             raise RuntimeError("客户端已关闭，无法发布消息")
 
-        # 处理消息体序列化
         try:
             if isinstance(message_body, MQMsgModel):
                 body = json.dumps(message_body.to_dict(),
@@ -371,102 +378,72 @@ class RabbitMQClient:
             else:
                 raise TypeError(f"不支持的消息体类型: {type(message_body)}")
         except Exception as e:
-            SYLogger.error(f"消息体序列化失败: {str(e)}", exc_info=True)
+            logger.error(f"消息体序列化失败: {e}")
             raise
 
-        # 构建消息对象
-        message = Message(
-            body=body,
-            headers=headers or {},
-            content_type=content_type,
-            delivery_mode=delivery_mode,
-        )
+        message = Message(body=body, headers=headers or {},
+                          content_type=content_type, delivery_mode=delivery_mode)
+        last_exception = None
 
-        # 发布重试逻辑
         for retry in range(retry_count):
             try:
-                # 确保连接有效
                 if not await self.is_connected:
-                    SYLogger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 核心：发布消息（添加 mandatory=True 和 timeout=5.0）
-                publish_result = await self._exchange.publish(
+                result = await self._exchange.publish(
                     message=message,
-                    routing_key=self.routing_key or self.queue_name or "#",
-                    mandatory=True,  # 强制路由到至少一个队列，否则返回None
-                    timeout=5.0      # 5秒超时控制，避免无限阻塞
+                    routing_key=self.routing_key,
+                    mandatory=True,
+                    timeout=5.0
                 )
 
-                # 处理 mandatory=True 结果：未路由到队列返回 None，直接抛出异常
-                if publish_result is None:
-                    raise RuntimeError(
-                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
-                    )
+                if result is None:
+                    raise RuntimeError(f"消息未找到匹配的队列: {self.routing_key}")
 
-                # 低版本 RobustChannel 异步确认，无需显式等待，仅日志说明
-                SYLogger.info(
-                    f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
-                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
-                )
+                logger.info(f"发布成功: {self.routing_key}")
                 return
-            except asyncio.TimeoutError:
-                SYLogger.error(
-                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
-                )
+
             except RuntimeError as e:
-                # 捕获 mandatory 未路由等业务异常
-                SYLogger.error(
-                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
-                )
+                if "未找到匹配的队列" in str(e):
+                    raise
+                last_exception = str(e)
+                await self._handle_publish_failure()
+
             except Exception as e:
-                SYLogger.error(
-                    f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
-                    exc_info=True
-                )
-                # 清理失效状态，下次重试重连
-                self._exchange = None
-            # 指数退避重试间隔（0.5s, 1s, 2s...）
-            await asyncio.sleep(0.5 * (2 ** retry))
+                last_exception = str(e)
+                logger.error(f"发布异常: {e}")
+                await self._handle_publish_failure()
 
-        # 所有重试失败，抛出最终异常
-        raise RuntimeError(
-            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
-            f"mandatory: True，timeout: 5.0s"
-        )
+            await asyncio.sleep(5)
+
+        raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
-        """关闭客户端（移除回调+释放资源）"""
         self._closed = True
-        SYLogger.info("开始关闭RabbitMQ客户端...")
+        logger.info("开始关闭RabbitMQ客户端...")
 
-        # 停止重连任务
         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:
-                SYLogger.debug("重连任务已取消")
+                pass
 
-        # 1. 停止消费
         await self.stop_consuming()
 
-        # 2. 释放通道到连接池
         async with self._connect_lock:
-            if self._channel and self._channel_conn:
-                try:
-                    # 移除连接关闭回调
-                    if self._conn_close_callback:
-                        self._channel_conn.close_callbacks.discard(
-                            self._conn_close_callback)
-                    await self.connection_pool.release_channel(self._channel, self._channel_conn)
-                    SYLogger.info("通道释放成功")
-                except Exception as e:
-                    SYLogger.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
             self._exchange = None
             self._queue = None
             self._message_handler = None
 
-        SYLogger.info("RabbitMQ客户端已完全关闭")
+            # 确保唤醒可能正在等待 connect 的任务
+            self._connecting = False
+            self._connect_condition.notify_all()
+
+        logger.info("客户端已关闭")