sycommon-python-lib 0.1.56b5__py3-none-any.whl → 0.1.57b4__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -0,0 +1,211 @@
+from typing import Dict
+import asyncio
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+from sycommon.rabbitmq.rabbitmq_service_core import RabbitMQCoreService
+
+logger = SYLogger
+
+
+class RabbitMQClientManager(RabbitMQCoreService):
+    """
+    RabbitMQ客户端管理类 - 负责客户端的创建、获取、重连、资源清理
+    """
+    # 客户端存储
+    _clients: Dict[str, RabbitMQClient] = {}
+    _init_locks: Dict[str, asyncio.Lock] = {}
+
+    # 模式标记
+    _has_listeners: bool = False
+    _has_senders: bool = False
+
+    @classmethod
+    def set_mode_flags(cls, has_listeners: bool = False, has_senders: bool = False) -> None:
+        """设置模式标记（是否有监听器/发送器）"""
+        cls._has_listeners = has_listeners
+        cls._has_senders = has_senders
+
+    @classmethod
+    async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
+        """清理客户端无效资源"""
+        try:
+            # 先停止消费
+            if client._consumer_tag:
+                await client.stop_consuming()
+            logger.debug("客户端无效资源清理完成（单通道无需归还）")
+        except Exception as e:
+            logger.warning(f"释放客户端无效资源失败: {str(e)}")
+        finally:
+            # 强制重置客户端状态
+            client._channel = None
+            client._channel_conn = None
+            client._exchange = None
+            client._queue = None
+            client._consumer_tag = None
+
+    @classmethod
+    async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
+        """客户端重连"""
+        if cls._is_shutdown or not (cls._connection_pool and await cls._connection_pool.is_alive):
+            return False
+
+        # 重连冷却
+        await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        try:
+            # 清理旧资源
+            await cls._clean_client_resources(client)
+
+            # 执行重连
+            await client.connect()
+
+            # 验证重连结果
+            if await client.is_connected:
+                logger.info(f"客户端 '{client_name}' 重连成功")
+                return True
+            else:
+                logger.warning(f"客户端 '{client_name}' 重连失败：资源未完全初始化")
+                return False
+        except Exception as e:
+            logger.error(f"客户端 '{client_name}' 重连失败: {str(e)}", exc_info=True)
+            return False
+
+    @classmethod
+    async def _create_client(cls, **kwargs) -> RabbitMQClient:
+        """创建客户端实例"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
+
+        # 等待连接池就绪
+        await cls.wait_for_pool_ready()
+
+        app_name = kwargs.get('app_name', cls._config.get(
+            "APP_NAME", "")) if cls._config else ""
+        queue_name = kwargs.get('queue_name', '')
+
+        create_if_not_exists = kwargs.get('create_if_not_exists', True)
+
+        processed_queue_name = queue_name
+        if create_if_not_exists and processed_queue_name and app_name:
+            if not processed_queue_name.endswith(f".{app_name}"):
+                processed_queue_name = f"{processed_queue_name}.{app_name}"
+                logger.info(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
+            else:
+                logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
+
+        logger.info(
+            f"创建客户端 - 原始队列名: {queue_name}, "
+            f"处理后队列名: {processed_queue_name}, "
+            f"是否创建队列: {create_if_not_exists}"
+        )
+
+        final_queue_name = None
+        if create_if_not_exists and processed_queue_name.endswith(f".{app_name}"):
+            final_queue_name = processed_queue_name
+
+        # 创建客户端实例
+        client = RabbitMQClient(
+            connection_pool=cls._connection_pool,
+            exchange_name=cls._config.get(
+                'exchange_name', "system.topic.exchange"),
+            exchange_type=kwargs.get('exchange_type', "topic"),
+            queue_name=final_queue_name,
+            app_name=app_name,
+            routing_key=kwargs.get(
+                'routing_key',
+                f"{queue_name.split('.')[0]}.#"
+            ),
+            durable=kwargs.get('durable', True),
+            auto_delete=kwargs.get('auto_delete', False),
+            auto_parse_json=kwargs.get('auto_parse_json', True),
+            create_if_not_exists=create_if_not_exists,
+            prefetch_count=kwargs.get('prefetch_count', 2),
+        )
+
+        # 连接客户端
+        await client.connect()
+
+        return client
+
+    @classmethod
+    async def get_client(
+        cls,
+        client_name: str = "default",
+        client_type: str = "sender",  # sender（发送器）/listener（监听器），默认sender
+        **kwargs
+    ) -> RabbitMQClient:
+        """
+        获取或创建RabbitMQ客户端
+        :param client_name: 客户端名称
+        :param client_type: 客户端类型 - sender(发送器)/listener(监听器)
+        :param kwargs: 其他参数
+        :return: RabbitMQClient实例
+        """
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
+
+        # 校验client_type合法性
+        if client_type not in ["sender", "listener"]:
+            raise ValueError(
+                f"client_type只能是sender/listener，当前值：{client_type}")
+
+        # 等待连接池就绪
+        await cls.wait_for_pool_ready()
+
+        # 确保锁存在
+        if client_name not in cls._init_locks:
+            cls._init_locks[client_name] = asyncio.Lock()
+
+        async with cls._init_locks[client_name]:
+            # ===== 原有“客户端已存在”的逻辑保留 =====
+            if client_name in cls._clients:
+                client = cls._clients[client_name]
+                # 核心：根据client_type重置客户端的队列创建配置
+                if client_type == "sender":
+                    client.create_if_not_exists = False
+                else:  # listener
+                    client.create_if_not_exists = True
+                    # 监听器必须有队列名，从kwargs补全
+                    if not client.queue_name and kwargs.get("queue_name"):
+                        client.queue_name = kwargs.get("queue_name")
+
+                if await client.is_connected:
+                    return client
+                else:
+                    logger.info(f"客户端 '{client_name}' 连接已断开，重新创建")
+                    await cls._clean_client_resources(client)
+
+            # ===== 核心逻辑：根据client_type统一控制队列创建 =====
+            if client_type == "sender":
+                kwargs["create_if_not_exists"] = False  # 禁用创建队列
+            else:
+                if not kwargs.get("queue_name"):
+                    raise ValueError("监听器类型必须指定queue_name参数")
+                kwargs["create_if_not_exists"] = True
+
+            client = await cls._create_client(
+                **kwargs
+            )
+
+            # 监听器额外验证队列创建结果
+            if client_type == "listener" and not client._queue:
+                raise RuntimeError(f"监听器队列 '{kwargs['queue_name']}' 创建失败")
+
+            # 存储客户端
+            cls._clients[client_name] = client
+            return client
+
+    @classmethod
+    async def shutdown_clients(cls, timeout: float = 15.0) -> None:
+        """关闭所有客户端"""
+        # 关闭所有客户端
+        for client in cls._clients.values():
+            try:
+                await client.close()
+            except Exception as e:
+                logger.error(f"关闭客户端失败: {str(e)}")
+
+        # 清理客户端状态
+        cls._clients.clear()
+        cls._init_locks.clear()

sycommon/rabbitmq/rabbitmq_service_connection_monitor.py

@@ -0,0 +1,73 @@
+import asyncio
+from typing import Optional
+from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
+from sycommon.logging.kafka_log import SYLogger
+
+logger = SYLogger
+
+
+class RabbitMQConnectionMonitor(RabbitMQClientManager):
+    """
+    RabbitMQ连接监控类 - 负责连接状态监控、自动重连
+    """
+    _connection_monitor_task: Optional[asyncio.Task] = None
+
+    @classmethod
+    async def _monitor_connections(cls):
+        """连接监控任务：定期检查所有客户端连接状态"""
+        logger.info("RabbitMQ连接监控任务启动")
+        while not cls._is_shutdown:
+            try:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+                # 跳过未初始化的连接池
+                if not cls._connection_pool or not cls._connection_pool._initialized:
+                    continue
+
+                # 检查连接池本身状态
+                pool_alive = await cls._connection_pool.is_alive
+                if not pool_alive:
+                    logger.error("RabbitMQ连接池已断开，等待原生自动重连")
+                    continue
+
+                # 检查所有客户端连接
+                for client_name, client in list(cls._clients.items()):
+                    try:
+                        client_connected = await client.is_connected
+                        if not client_connected:
+                            logger.warning(
+                                f"客户端 '{client_name}' 连接异常，触发重连")
+                            asyncio.create_task(
+                                cls._reconnect_client(client_name, client))
+                    except Exception as e:
+                        logger.error(
+                            f"监控客户端 '{client_name}' 连接状态失败: {str(e)}", exc_info=True)
+
+            except Exception as e:
+                logger.error("RabbitMQ连接监控任务异常", exc_info=True)
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        logger.info("RabbitMQ连接监控任务停止")
+
+    @classmethod
+    def start_connection_monitor(cls) -> None:
+        """启动连接监控任务"""
+        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+            return
+
+        cls._connection_monitor_task = asyncio.create_task(
+            cls._monitor_connections())
+
+    @classmethod
+    async def stop_connection_monitor(cls, timeout: float = 15.0) -> None:
+        """停止连接监控任务"""
+        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+            cls._connection_monitor_task.cancel()
+            try:
+                await asyncio.wait_for(cls._connection_monitor_task, timeout=timeout)
+            except asyncio.TimeoutError:
+                logger.warning("连接监控任务关闭超时")
+            except Exception as e:
+                logger.error(f"关闭连接监控任务失败: {str(e)}")
+
+        cls._connection_monitor_task = None

sycommon/rabbitmq/rabbitmq_service_consumer_manager.py

@@ -0,0 +1,285 @@
+from typing import Dict, List, Callable, Coroutine, Any
+import asyncio
+from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.models.mqlistener_config import RabbitMQListenerConfig
+from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
+from sycommon.models.mqmsg_model import MQMsgModel
+
+logger = SYLogger
+
+
+class RabbitMQConsumerManager(RabbitMQClientManager):
+    """
+    RabbitMQ消费者管理类 - 负责监听器设置、消费启动/停止、消费验证
+    """
+    # 消费者相关状态
+    _message_handlers: Dict[str, Callable[[
+        MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = {}
+    _consumer_tasks: Dict[str, asyncio.Task] = {}
+    _consumer_events: Dict[str, asyncio.Event] = {}
+    _consumer_tags: Dict[str, ConsumerTag] = {}
+
+    # 配置常量
+    CONSUMER_START_TIMEOUT = 30  # 消费启动超时（秒）
+
+    @classmethod
+    async def add_listener(
+        cls,
+        queue_name: str,
+        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], **kwargs
+    ) -> None:
+        """添加消息监听器"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法添加监听器")
+            return
+
+        if queue_name in cls._message_handlers:
+            logger.info(f"监听器 '{queue_name}' 已存在，跳过重复添加")
+            return
+
+        # 创建并初始化客户端
+        await cls.get_client(
+            client_name=queue_name,
+            client_type="listener",
+            queue_name=queue_name,
+            ** kwargs
+        )
+
+        # 注册消息处理器
+        cls._message_handlers[queue_name] = handler
+        logger.info(f"监听器 '{queue_name}' 已添加")
+
+    @classmethod
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
+        """设置消息监听器"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法设置监听器")
+            return
+
+        cls.set_mode_flags(has_listeners=True, has_senders=has_senders)
+        logger.info(f"开始设置 {len(listeners)} 个消息监听器")
+
+        for idx, listener_config in enumerate(listeners):
+            try:
+                # 转换配置
+                listener_dict = listener_config.model_dump()
+                listener_dict['create_if_not_exists'] = True
+                listener_dict['prefetch_count'] = listener_config.prefetch_count
+                queue_name = listener_dict['queue_name']
+
+                logger.info(
+                    f"设置监听器 {idx+1}/{len(listeners)}: {queue_name} (prefetch_count: {listener_config.prefetch_count})")
+
+                # 添加监听器
+                await cls.add_listener(**listener_dict)
+            except Exception as e:
+                logger.error(
+                    f"设置监听器 {idx+1} 失败: {str(e)}", exc_info=True)
+                logger.warning("继续处理其他监听器")
+
+        # 启动所有消费者
+        await cls.start_all_consumers()
+
+        # 验证消费者启动结果
+        await cls._verify_consumers_started()
+
+        logger.info(f"消息监听器设置完成")
+
+    @classmethod
+    async def _verify_consumers_started(cls, timeout: int = 30) -> None:
+        """验证消费者是否成功启动"""
+        start_time = asyncio.get_event_loop().time()
+        required_clients = list(cls._message_handlers.keys())
+        running_clients = []
+
+        while len(running_clients) < len(required_clients) and \
+                (asyncio.get_event_loop().time() - start_time) < timeout and \
+                not cls._is_shutdown:
+
+            running_clients = [
+                name for name, task in cls._consumer_tasks.items()
+                if not task.done() and name in cls._consumer_tags
+            ]
+
+            logger.info(
+                f"消费者启动验证: {len(running_clients)}/{len(required_clients)} 已启动")
+            await asyncio.sleep(1)
+
+        failed_clients = [
+            name for name in required_clients if name not in running_clients and not cls._is_shutdown]
+        if failed_clients:
+            logger.error(f"以下消费者启动失败: {', '.join(failed_clients)}")
+            for client_name in failed_clients:
+                logger.info(f"尝试重新启动消费者: {client_name}")
+                asyncio.create_task(cls.start_consumer(client_name))
+
+    @classmethod
+    async def start_all_consumers(cls) -> None:
+        """启动所有已注册的消费者"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法启动消费者")
+            return
+
+        for client_name in cls._message_handlers:
+            await cls.start_consumer(client_name)
+
+    @classmethod
+    async def start_consumer(cls, client_name: str) -> None:
+        """启动指定客户端的消费者"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法启动消费者")
+            return
+
+        # 检查任务状态
+        if client_name in cls._consumer_tasks:
+            existing_task = cls._consumer_tasks[client_name]
+            if not existing_task.done():
+                if existing_task.exception() is not None:
+                    logger.info(f"消费者 '{client_name}' 任务异常，重启")
+                    existing_task.cancel()
+                else:
+                    logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+                    return
+            else:
+                logger.info(f"消费者 '{client_name}' 任务已完成，重新启动")
+
+        if client_name not in cls._clients:
+            raise ValueError(f"RabbitMQ客户端 '{client_name}' 未初始化")
+
+        client = cls._clients[client_name]
+        handler = cls._message_handlers.get(client_name)
+
+        if not handler:
+            logger.warning(f"未找到客户端 '{client_name}' 的处理器")
+            return
+
+        # 设置消息处理器
+        await client.set_message_handler(handler)
+
+        # 确保客户端已连接
+        start_time = asyncio.get_event_loop().time()
+        while not await client.is_connected and not cls._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
+                raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
+
+            logger.info(f"等待客户端 '{client_name}' 连接就绪...")
+            await asyncio.sleep(1)
+        if cls._is_shutdown:
+            return
+
+        # 创建停止事件
+        stop_event = asyncio.Event()
+        cls._consumer_events[client_name] = stop_event
+
+        # 定义消费任务
+        async def consume_task():
+            try:
+                # 启动消费，带重试机制
+                max_attempts = 3
+                attempt = 0
+                consumer_tag = None
+
+                while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
+                    try:
+                        # 启动消费前再次校验
+                        if not await client.is_connected:
+                            logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
+                            await client.connect()
+
+                        if not client._queue:
+                            raise Exception("队列未初始化完成")
+                        if not client._message_handler:
+                            raise Exception("消息处理器未设置")
+
+                        consumer_tag = await client.start_consuming()
+                        if consumer_tag:
+                            break
+                    except Exception as e:
+                        attempt += 1
+                        logger.warning(
+                            f"启动消费者尝试 {attempt}/{max_attempts} 失败: {str(e)}")
+                        if attempt < max_attempts:
+                            await asyncio.sleep(2)
+
+                if cls._is_shutdown:
+                    return
+
+                if not consumer_tag:
+                    raise Exception(f"经过 {max_attempts} 次尝试仍无法启动消费者")
+
+                # 记录消费者标签
+                cls._consumer_tags[client_name] = consumer_tag
+                logger.info(
+                    f"消费者 '{client_name}' 开始消费（单通道），tag: {consumer_tag}"
+                )
+
+                # 等待停止事件
+                await stop_event.wait()
+                logger.info(f"收到停止信号，消费者 '{client_name}' 准备退出")
+
+            except asyncio.CancelledError:
+                logger.info(f"消费者 '{client_name}' 被取消")
+            except Exception as e:
+                logger.error(
+                    f"消费者 '{client_name}' 错误: {str(e)}", exc_info=True)
+                # 非主动停止时尝试重启
+                if not stop_event.is_set() and not cls._is_shutdown:
+                    logger.info(f"尝试重启消费者 '{client_name}'")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
+                    asyncio.create_task(cls.start_consumer(client_name))
+            finally:
+                # 清理资源
+                try:
+                    await client.stop_consuming()
+                except Exception as e:
+                    logger.error(f"停止消费者 '{client_name}' 时出错: {str(e)}")
+
+                # 移除状态记录
+                if client_name in cls._consumer_tags:
+                    del cls._consumer_tags[client_name]
+                if client_name in cls._consumer_events:
+                    del cls._consumer_events[client_name]
+
+                logger.info(f"消费者 '{client_name}' 已停止")
+
+        # 创建并跟踪消费任务
+        task = asyncio.create_task(
+            consume_task(), name=f"consumer-{client_name}")
+        cls._consumer_tasks[client_name] = task
+
+        # 添加任务完成回调
+        def task_done_callback(t: asyncio.Task) -> None:
+            try:
+                if t.done():
+                    t.result()
+            except Exception as e:
+                logger.error(f"消费者任务 '{client_name}' 异常结束: {str(e)}")
+                if client_name in cls._message_handlers and not cls._is_shutdown:
+                    asyncio.create_task(cls.start_consumer(client_name))
+
+        task.add_done_callback(task_done_callback)
+        logger.info(f"消费者任务 '{client_name}' 已创建")
+
+    @classmethod
+    async def shutdown_consumers(cls, timeout: float = 15.0) -> None:
+        """关闭所有消费者"""
+        # 停止所有消费者任务
+        for client_name, task in cls._consumer_tasks.items():
+            if not task.done():
+                # 触发停止事件
+                if client_name in cls._consumer_events:
+                    cls._consumer_events[client_name].set()
+                # 取消任务
+                task.cancel()
+                try:
+                    await asyncio.wait_for(task, timeout=timeout)
+                except Exception as e:
+                    logger.error(f"关闭消费者 '{client_name}' 失败: {str(e)}")
+
+        # 清理消费者状态
+        cls._message_handlers.clear()
+        cls._consumer_tasks.clear()
+        cls._consumer_events.clear()
+        cls._consumer_tags.clear()

sycommon/rabbitmq/rabbitmq_service_core.py

@@ -0,0 +1,117 @@
+import asyncio
+from typing import Optional
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQConnectionPool
+
+logger = SYLogger
+
+
+class RabbitMQCoreService:
+    """
+    RabbitMQ核心服务类 - 负责基础初始化、连接池管理、全局状态控制
+    """
+    # 全局共享状态
+    _config: Optional[dict] = None
+    _connection_pool: Optional[RabbitMQConnectionPool] = None
+    _is_shutdown: bool = False
+    _shutdown_lock = asyncio.Lock()
+
+    # 配置常量
+    RECONNECT_INTERVAL = 15  # 重连基础间隔（秒）
+    CONNECTION_POOL_TIMEOUT = 30  # 连接池初始化超时（秒）
+
+    @classmethod
+    def init_config(cls, config: dict) -> None:
+        """初始化基础配置（从Nacos加载）"""
+        from sycommon.synacos.nacos_service import NacosService
+
+        if cls._config:
+            logger.warning("RabbitMQ配置已初始化，无需重复调用")
+            return
+
+        # 从Nacos获取MQ配置
+        cls._config = NacosService(config).share_configs.get(
+            "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
+        cls._config["APP_NAME"] = config.get("Name", "")
+
+        # 打印关键配置信息
+        logger.info(
+            f"RabbitMQ服务初始化 - 集群节点: {cls._config.get('host')}, "
+            f"端口: {cls._config.get('port')}, "
+            f"虚拟主机: {cls._config.get('virtual-host')}, "
+            f"应用名: {cls._config.get('APP_NAME')}, "
+            f"心跳: {cls._config.get('heartbeat', 30)}s"
+        )
+        cls._is_shutdown = False
+
+    @classmethod
+    async def init_connection_pool(cls) -> None:
+        """初始化单通道连接池（带重试机制）"""
+        if cls._connection_pool or not cls._config or cls._is_shutdown:
+            return
+
+        try:
+            # 解析集群节点
+            hosts_str = cls._config.get('host', "")
+            hosts_list = [host.strip()
+                          for host in hosts_str.split(',') if host.strip()]
+            if not hosts_list:
+                raise ValueError("RabbitMQ集群配置为空，请检查host参数")
+
+            global_prefetch_count = cls._config.get('prefetch_count', 2)
+
+            # 创建单通道连接池
+            cls._connection_pool = RabbitMQConnectionPool(
+                hosts=hosts_list,
+                port=cls._config.get('port', 5672),
+                username=cls._config.get('username', ""),
+                password=cls._config.get('password', ""),
+                virtualhost=cls._config.get('virtual-host', "/"),
+                app_name=cls._config.get("APP_NAME", ""),
+                prefetch_count=global_prefetch_count,
+                heartbeat=cls._config.get('heartbeat', 15),
+                connection_timeout=cls._config.get('connection_timeout', 15),
+                reconnect_interval=cls._config.get('reconnect_interval', 5),
+            )
+
+            # 初始化连接池
+            await asyncio.wait_for(cls._connection_pool.init_pools(), timeout=cls.CONNECTION_POOL_TIMEOUT)
+            logger.info("RabbitMQ单通道连接池初始化成功")
+
+        except Exception as e:
+            logger.error(f"RabbitMQ连接池初始化失败: {str(e)}", exc_info=True)
+            # 连接池初始化失败时重试（未关闭状态下）
+            if not cls._is_shutdown:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+                asyncio.create_task(cls.init_connection_pool())
+
+    @classmethod
+    async def wait_for_pool_ready(cls) -> None:
+        """等待连接池就绪（带超时）"""
+        if not cls._config:
+            raise ValueError("RabbitMQ配置尚未初始化，请先调用init_config方法")
+
+        start_time = asyncio.get_event_loop().time()
+        while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > cls.CONNECTION_POOL_TIMEOUT:
+                raise TimeoutError("等待连接池初始化超时")
+            await asyncio.sleep(1)
+
+        if cls._is_shutdown:
+            raise RuntimeError("服务关闭中，取消等待连接池")
+
+    @classmethod
+    async def shutdown_core_resources(cls, timeout: float = 15.0) -> None:
+        """关闭核心资源（连接池）"""
+        # 关闭连接池
+        if cls._connection_pool and cls._connection_pool._initialized:
+            try:
+                await cls._connection_pool.close()
+                logger.info("RabbitMQ单通道连接池已关闭")
+            except Exception as e:
+                logger.error(f"关闭连接池失败: {str(e)}")
+
+        # 清理核心状态
+        cls._config = None
+        cls._connection_pool = None