sycommon-python-lib 0.1.49__py3-none-any.whl → 0.1.51__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -15,7 +15,6 @@ from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
-
 logger = SYLogger
 
 
@@ -23,8 +22,8 @@ class RabbitMQClient:
     """
     RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
     核心特性：
-    1. 基于连接池复用资源，性能优化
-    2. 连接/通道失效时自动重建，高可用（限制并发重连）
+    1. 基于单通道连接池复用资源，性能优化
+    2. 依赖连接池原生自动重连，客户端仅重建自身资源
     3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
     4. 消费支持手动ACK/NACK
     5. 兼容JSON/字符串/字典消息格式
@@ -41,7 +40,6 @@ class RabbitMQClient:
         auto_delete: bool = False,
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
-        prefetch_count: int = 2,
         **kwargs,
     ):
         # 依赖注入：连接池（必须已初始化）
@@ -54,8 +52,8 @@ class RabbitMQClient:
         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.queue_name = queue_name.strip() if queue_name else None
@@ -65,9 +63,6 @@ class RabbitMQClient:
         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._channel: Optional[Channel] = None
         self._channel_conn: Optional[AbstractRobustConnection] = None  # 通道所属连接
@@ -83,12 +78,10 @@ class RabbitMQClient:
         self._connect_lock = asyncio.Lock()
         # 跟踪连接关闭回调（用于后续移除）
         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
         # 连接失败计数器（用于告警）
@@ -102,7 +95,7 @@ class RabbitMQClient:
         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
@@ -110,23 +103,52 @@ class RabbitMQClient:
                 and (not self.queue_name or self._queue is not None)
             )
         except Exception as e:
-            SYLogger.warning(f"检查连接状态失败: {str(e)}")
+            logger.warning(f"检查连接状态失败: {str(e)}")
             return False
 
+    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,
+            )
+            # 绑定队列到交换机
+            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}）"
+            )
+
     async def connect(self) -> None:
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
         async with self._connect_lock:
-            # 释放旧资源（保留原有回调清理逻辑）
-            if self._channel and self._channel_conn:
-                try:
-                    if self._conn_close_callback and self._channel_conn:
-                        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)}")
+            # 释放旧资源（回调+通道，单通道无需归还，仅清理状态）
+            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
@@ -134,17 +156,17 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
             try:
-                # 从连接池获取通道+连接（连接池返回的是 RobustChannel）
+                # 从单通道池获取通道+连接（连接池自动确保通道有效）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
                     """连接关闭回调：触发固定间隔重连"""
-                    SYLogger.warning(
+                    logger.warning(
                         f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
                     self._reconnect_fail_count += 1
                     # 超过阈值告警
                     if self._reconnect_fail_count >= self._reconnect_alert_threshold:
-                        SYLogger.error(
+                        logger.error(
                             f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
                     if not self._closed:
                         asyncio.create_task(self._safe_reconnect())
@@ -154,97 +176,54 @@ class RabbitMQClient:
                     self._channel_conn.close_callbacks.add(
                         self._conn_close_callback)
 
-                # 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}）")
-
-                # 5. 声明队列（如果配置了队列名）
-                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,
-                    )
-                    # 绑定队列到交换机
-                    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}）"
-                    )
+                # 重建交换机/队列资源
+                await self._rebuild_resources()
 
                 # 重连成功，重置失败计数器
                 self._reconnect_fail_count = 0
-                SYLogger.info("客户端连接初始化完成")
+                logger.info("客户端连接初始化完成")
             except Exception as e:
-                SYLogger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+                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)
-                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
 
     async def _safe_reconnect(self):
-        """安全重连：信号量控制并发+固定15秒间隔，避免短时间大量重连"""
-        # 1. 信号量控制：限制同时进行的重连任务数（默认1个）
+        """安全重连：信号量控制并发+固定15秒间隔"""
         async with self._reconnect_semaphore:
-            # 2. 检查是否已有重连任务在运行（双重保障）
+            # 检查是否已有重连任务在运行
             if self._current_reconnect_task and not self._current_reconnect_task.done():
-                SYLogger.debug("已有重连任务在运行，跳过重复触发")
+                logger.debug("已有重连任务在运行，跳过重复触发")
                 return
 
-            async with self._reconnect_task_lock:
-                if self._closed or await self.is_connected:
-                    SYLogger.debug("客户端已关闭或已连接，取消重连")
-                    return
+            if self._closed or await self.is_connected:
+                logger.debug("客户端已关闭或已连接，取消重连")
+                return
 
-                # 3. 固定15秒重连间隔（避免频繁重试）
-                SYLogger.info(f"将在15秒后尝试重连...")
-                await asyncio.sleep(self._RECONNECT_INTERVAL)
+            # 固定15秒重连间隔
+            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:
+                logger.debug("重连等待期间客户端状态变化，取消重连")
+                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:
+                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
 
     async def set_message_handler(
         self,
@@ -256,7 +235,7 @@ class RabbitMQClient:
 
         async with self._consume_lock:
             self._message_handler = handler
-            SYLogger.info("消息处理器设置成功")
+            logger.info("消息处理器设置成功")
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
         """启动消息消费（支持自动重连）"""
@@ -270,7 +249,7 @@ class RabbitMQClient:
             if not await self.is_connected:
                 await self.connect()
             if not self._queue:
-                raise RuntimeError("未配置队列名，无法启动消费")
+                raise RuntimeError("未配置队列名或队列未创建，无法启动消费")
 
             # 2. 定义消费回调（包含异常处理和重连逻辑）
             async def consume_callback(message: AbstractIncomingMessage):
@@ -282,7 +261,7 @@ class RabbitMQClient:
                                 message.body.decode("utf-8"))
                             msg_obj = MQMsgModel(**body_dict)
                         except json.JSONDecodeError as e:
-                            SYLogger.error(
+                            logger.error(
                                 f"JSON消息解析失败: {str(e)}，消息体: {message.body[:100]}...")
                             await message.nack(requeue=False)  # 解析失败，不重入队
                             return
@@ -293,51 +272,59 @@ class RabbitMQClient:
                             delivery_tag=message.delivery_tag,
                         )
 
-                    # 调用消息处理器（必须await，避免协程未等待警告）
+                    # 调用消息处理器
                     await self._message_handler(msg_obj, message)
 
-                    # 手动ACK（消息处理成功）
+                    # 手动ACK
                     await message.ack()
-                    SYLogger.debug(
+                    logger.debug(
                         f"消息处理成功，delivery_tag: {message.delivery_tag}")
 
                 except Exception as e:
-                    SYLogger.error(
+                    logger.error(
                         f"消息处理失败，delivery_tag: {message.delivery_tag}",
                         exc_info=True
                     )
                     # 处理失败逻辑：首次失败重入队，再次失败丢弃
                     if message.redelivered:
-                        SYLogger.warning(
+                        logger.warning(
                             f"消息已重入队过，本次拒绝入队: {message.delivery_tag}")
                         await message.reject(requeue=False)
                     else:
-                        SYLogger.warning(f"消息重入队: {message.delivery_tag}")
+                        logger.warning(f"消息重入队: {message.delivery_tag}")
                         await message.nack(requeue=True)
 
-                    # 检查连接状态，失效则触发重连
+                    # 连接失效则触发重连
                     if not await self.is_connected:
-                        SYLogger.warning("连接已失效，触发客户端重连")
+                        logger.warning("连接已失效，触发客户端重连")
                         asyncio.create_task(self._safe_reconnect())
 
-            # 3. 启动消费
+            # 3. 启动消费（单通道消费，避免阻塞发布需确保业务回调非阻塞）
             self._consumer_tag = await self._queue.consume(consume_callback)
-            SYLogger.info(
+            logger.info(
                 f"开始消费队列: {self._queue.name}，consumer_tag: {self._consumer_tag}"
             )
             return self._consumer_tag
 
     async def stop_consuming(self) -> None:
-        """停止消息消费"""
+        """停止消息消费（修复：移除 _queue.is_closed 判断）"""
         async with self._consume_lock:
-            if self._consumer_tag and self._queue and not self._queue.is_closed:
-                try:
-                    await self._queue.cancel(self._consumer_tag)
-                    SYLogger.info(f"停止消费成功，consumer_tag: {self._consumer_tag}")
-                except Exception as e:
-                    SYLogger.error(f"停止消费失败: {str(e)}", exc_info=True)
-                finally:
-                    self._consumer_tag = None
+            try:
+                # 判断 consumer_tag 和 queue 是否存在，通道状态通过 _channel 校验
+                if self._consumer_tag and self._queue and self._channel and not self._channel.is_closed:
+                    # 用通道取消消费（队列无cancel方法）
+                    await self._channel.basic_cancel(self._consumer_tag)
+                    logger.info(
+                        f"停止消费成功，consumer_tag: {self._consumer_tag}，队列: {self._queue.name}")
+                elif self._consumer_tag and self._queue:
+                    # 通道已关闭，无需执行cancel（消费已自动停止）
+                    logger.warning(
+                        f"通道已关闭，无需取消消费（consumer_tag: {self._consumer_tag}）")
+            except Exception as e:
+                logger.error(
+                    f"停止消费者 '{self._queue.name if self._queue else '未知队列'}' 时出错: {str(e)}", exc_info=True)
+            finally:
+                self._consumer_tag = None  # 无论成败，清理消费标签
 
     async def publish(
         self,
@@ -371,7 +358,7 @@ class RabbitMQClient:
             else:
                 raise TypeError(f"不支持的消息体类型: {type(message_body)}")
         except Exception as e:
-            SYLogger.error(f"消息体序列化失败: {str(e)}", exc_info=True)
+            logger.error(f"消息体序列化失败: {str(e)}", exc_info=True)
             raise
 
         # 构建消息对象
@@ -387,49 +374,47 @@ class RabbitMQClient:
             try:
                 # 确保连接有效
                 if not await self.is_connected:
-                    SYLogger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
+                    logger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 核心：发布消息（添加 mandatory=True 和 timeout=5.0）
+                # 核心：发布消息（mandatory=True 确保路由有效，timeout=5s 避免阻塞）
                 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秒超时控制，避免无限阻塞
+                    mandatory=True,
+                    timeout=5.0
                 )
 
-                # 处理 mandatory=True 结果：未路由到队列返回 None，直接抛出异常
+                # 处理 mandatory 未路由场景
                 if publish_result is None:
                     raise RuntimeError(
                         f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
                     )
 
-                # 低版本 RobustChannel 异步确认，无需显式等待，仅日志说明
-                SYLogger.info(
+                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:
-                SYLogger.error(
+                logger.error(
                     f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
                 )
             except RuntimeError as e:
-                # 捕获 mandatory 未路由等业务异常
-                SYLogger.error(
+                logger.error(
                     f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
                 )
             except Exception as e:
-                SYLogger.error(
+                logger.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))
 
-        # 所有重试失败，抛出最终异常
+        # 所有重试失败
         raise RuntimeError(
             f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
             f"mandatory: True，timeout: 5.0s"
@@ -438,7 +423,7 @@ class RabbitMQClient:
     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():
@@ -446,27 +431,20 @@ class RabbitMQClient:
             try:
                 await self._current_reconnect_task
             except asyncio.CancelledError:
-                SYLogger.debug("重连任务已取消")
+                logger.debug("重连任务已取消")
 
         # 1. 停止消费
         await self.stop_consuming()
 
-        # 2. 释放通道到连接池
+        # 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客户端已完全关闭")
+        logger.info("RabbitMQ客户端已完全关闭")