sycommon-python-lib 0.1.52a0__tar.gz → 0.1.55b1__tar.gz

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/PKG-INFO

@@ -1,24 +1,25 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.52a0
+Version: 0.1.55b1
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: decorator>=5.2.1
-Requires-Dist: fastapi>=0.121.2
-Requires-Dist: kafka-python>=2.2.16
+Requires-Dist: fastapi>=0.127.0
+Requires-Dist: kafka-python>=2.3.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
-Requires-Dist: nacos-sdk-python>=2.0.9
-Requires-Dist: pydantic>=2.12.4
+Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
+Requires-Dist: psutil>=7.1.3
+Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: sqlalchemy>=2.0.44
-Requires-Dist: starlette>=0.49.3
-Requires-Dist: uuid>=1.30
-Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.45
+Requires-Dist: starlette>=0.50.0
+Requires-Dist: uvicorn>=0.40.0
 
 # sycommon-python-lib
 

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/pyproject.toml

@@ -1,25 +1,26 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.52-alpha"
+version = "0.1.55-beta1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "aio-pika>=9.5.8",
     "aiohttp>=3.13.2",
+    "aiomysql>=0.3.2",
     "decorator>=5.2.1",
-    "fastapi>=0.121.2",
-    "kafka-python>=2.2.16",
+    "fastapi>=0.127.0",
+    "kafka-python>=2.3.0",
     "loguru>=0.7.3",
     "mysql-connector-python>=9.5.0",
-    "nacos-sdk-python>=2.0.9",
-    "pydantic>=2.12.4",
+    "nacos-sdk-python>=2.0.9,<3.0",
+    "psutil>=7.1.3",
+    "pydantic>=2.12.5",
     "python-dotenv>=1.2.1",
     "pyyaml>=6.0.3",
-    "sqlalchemy>=2.0.44",
-    "starlette>=0.49.3",
-    "uuid>=1.30",
-    "uvicorn>=0.38.0",
+    "sqlalchemy[asyncio]>=2.0.45",
+    "starlette>=0.50.0",
+    "uvicorn>=0.40.0",
 ]
 
 [tool.setuptools]

sycommon_python_lib-0.1.55b1/src/sycommon/database/async_base_db_service.py

@@ -0,0 +1,36 @@
+from contextlib import asynccontextmanager
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sycommon.config.Config import SingletonMeta
+from sycommon.database.async_database_service import AsyncDatabaseService
+from sycommon.logging.kafka_log import SYLogger
+
+
+class AsyncBaseDBService(metaclass=SingletonMeta):
+    """数据库操作基础服务类，封装异步会话管理功能"""
+
+    def __init__(self):
+        # 获取异步引擎 (假设 DatabaseService.engine() 返回的是 AsyncEngine)
+        self.engine = AsyncDatabaseService.engine()
+
+        # 创建异步 Session 工厂
+        # class_=AsyncSession 是必须的，用于指定生成的是异步会话
+        self.Session = async_sessionmaker(
+            bind=self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
+
+    @asynccontextmanager
+    async def session(self):
+        """
+        异步数据库会话上下文管理器
+        自动处理会话的创建、提交、回滚和关闭
+        """
+        async with self.Session() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                SYLogger.error(f"Database operation failed: {str(e)}")
+                raise

sycommon_python_lib-0.1.55b1/src/sycommon/database/async_database_service.py

@@ -0,0 +1,96 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy import text
+
+from sycommon.config.Config import SingletonMeta
+from sycommon.config.DatabaseConfig import DatabaseConfig, convert_dict_keys
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.logging.async_sql_logger import AsyncSQLTraceLogger
+from sycommon.synacos.nacos_service import NacosService
+
+
+class AsyncDatabaseService(metaclass=SingletonMeta):
+    _engine = None
+
+    @staticmethod
+    async def setup_database(config: dict, shareConfigKey: str):
+        common = NacosService(config).share_configs.get(shareConfigKey, {})
+        if common and common.get('spring', {}).get('datasource', None):
+            databaseConfig = common.get('spring', {}).get('datasource', None)
+            converted_dict = convert_dict_keys(databaseConfig)
+            db_config = DatabaseConfig.model_validate(converted_dict)
+
+            # 初始化 DatabaseConnector (传入配置)
+            connector = AsyncDatabaseConnector(db_config)
+
+            # 赋值 engine
+            AsyncDatabaseService._engine = connector.engine
+
+            # 执行异步测试连接
+            if not await connector.test_connection():
+                raise Exception("Database connection test failed")
+
+    @staticmethod
+    def engine():
+        return AsyncDatabaseService._engine
+
+
+class AsyncDatabaseConnector(metaclass=SingletonMeta):
+    def __init__(self, db_config: DatabaseConfig):
+        # 从 DatabaseConfig 中提取数据库连接信息
+        self.db_user = db_config.username
+        self.db_password = db_config.password
+
+        # 提取 URL 中的主机、端口和数据库名
+        url_parts = db_config.url.split('//')[1].split('/')
+        host_port = url_parts[0].split(':')
+        self.db_host = host_port[0]
+        self.db_port = host_port[1]
+        self.db_name = url_parts[1].split('?')[0]
+
+        # 提取 URL 中的参数
+        params_str = url_parts[1].split('?')[1] if len(
+            url_parts[1].split('?')) > 1 else ''
+        params = {}
+        for param in params_str.split('&'):
+            if param:
+                key, value = param.split('=')
+                params[key] = value
+
+        # 在params中去掉指定的参数
+        for key in ['useUnicode', 'characterEncoding', 'serverTimezone', 'zeroDateTimeBehavior']:
+            if key in params:
+                del params[key]
+
+        # 构建数据库连接 URL
+        # 注意：这里将 mysqlconnector 替换为 aiomysql 以支持异步
+        self.db_url = f'mysql+aiomysql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}'
+
+        SYLogger.info(f"Database URL: {self.db_url}")
+
+        # 优化连接池配置
+        # 使用 create_async_engine 替代 create_engine
+        self.engine = create_async_engine(
+            self.db_url,
+            connect_args=params,
+            pool_size=10,  # 连接池大小
+            max_overflow=20,  # 最大溢出连接数
+            pool_timeout=30,  # 连接超时时间（秒）
+            pool_recycle=3600,  # 连接回收时间（秒）
+            pool_pre_ping=True,  # 每次获取连接前检查连接是否有效
+            echo=False,  # 打印 SQL 语句
+        )
+
+        # 注册 SQL 日志拦截器 (注意：SQLTraceLogger 需要支持异步引擎，或者您可能需要调整日志逻辑)
+        # 假设 SQLTraceLogger.setup_sql_logging 能够处理 AsyncEngine
+        AsyncSQLTraceLogger.setup_sql_logging(self.engine)
+
+    async def test_connection(self):
+        try:
+            # 异步上下文管理器
+            async with self.engine.connect() as connection:
+                # 执行简单查询
+                await connection.execute(text("SELECT 1"))
+                return True
+        except Exception as e:
+            SYLogger.error(f"Database connection test failed: {e}")
+            return False

sycommon_python_lib-0.1.55b1/src/sycommon/logging/async_sql_logger.py

@@ -0,0 +1,65 @@
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import AsyncEngine
+from sycommon.logging.kafka_log import SYLogger
+import time
+from datetime import datetime
+from decimal import Decimal
+
+
+class AsyncSQLTraceLogger:
+    @staticmethod
+    def setup_sql_logging(engine):
+        """
+        为 SQLAlchemy 异步引擎注册事件监听器
+        注意：必须监听 engine.sync_engine，而不能直接监听 AsyncEngine
+        """
+        def serialize_params(params):
+            """处理特殊类型参数的序列化"""
+            if isinstance(params, (list, tuple)):
+                return [serialize_params(p) for p in params]
+            elif isinstance(params, dict):
+                return {k: serialize_params(v) for k, v in params.items()}
+            elif isinstance(params, datetime):
+                return params.isoformat()
+            elif isinstance(params, Decimal):
+                return float(params)
+            else:
+                return params
+
+        # ========== 核心修改 ==========
+        # 必须通过 engine.sync_engine 来获取底层的同步引擎进行监听
+        target = engine.sync_engine
+
+        @event.listens_for(target, "after_cursor_execute")
+        def after_cursor_execute(
+            conn, cursor, statement, parameters, context, executemany
+        ):
+            try:
+                # 从连接选项中获取开始时间
+                # conn 在这里是同步连接对象
+                start_time = conn.info.get('_start_time') or \
+                    conn._execution_options.get("_start_time", time.time())
+
+                execution_time = (time.time() - start_time) * 1000
+
+                sql_log = {
+                    "type": "SQL",
+                    "statement": statement,
+                    "parameters": serialize_params(parameters),
+                    "execution_time_ms": round(execution_time, 2),
+                }
+
+                # 注意：SYLogger.info 必须是线程安全的或非阻塞的，否则可能影响异步性能
+                SYLogger.info(f"SQL执行: {sql_log}")
+            except Exception as e:
+                SYLogger.error(f"SQL日志处理失败: {str(e)}")
+
+        @event.listens_for(target, "before_cursor_execute")
+        def before_cursor_execute(
+            conn, cursor, statement, parameters, context, executemany
+        ):
+            try:
+                # 记录开始时间到 execution_options
+                conn = conn.execution_options(_start_time=time.time())
+            except Exception as e:
+                SYLogger.error(f"SQL开始时间记录失败: {str(e)}")

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/src/sycommon/logging/kafka_log.py

@@ -114,7 +114,7 @@ class KafkaLogger(metaclass=SingletonMeta):
                     trace_id = None
 
                 if not trace_id:
-                    trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
+                    trace_id = SYLogger.get_trace_id() or Snowflake.id
 
                 # 获取线程/协程信息
                 thread_info = SYLogger._get_execution_context()
@@ -173,7 +173,7 @@ class KafkaLogger(metaclass=SingletonMeta):
                     "className": "",
                     "sqlCost": 0,
                     "size": len(str(message)),
-                    "uid": int(Snowflake.next_id())  # 独立新的id
+                    "uid": int(Snowflake.id)  # 独立新的id
                 }
 
                 # 智能队列管理
@@ -212,7 +212,7 @@ class KafkaLogger(metaclass=SingletonMeta):
             return
 
         # 获取当前的trace_id
-        trace_id = SYLogger.get_trace_id() or Snowflake.next_id()
+        trace_id = SYLogger.get_trace_id() or Snowflake.id
 
         # 构建错误日志
         error_log = {
@@ -459,7 +459,7 @@ class SYLogger:
 
     @staticmethod
     def _log(msg: any, level: str = "INFO"):
-        trace_id = SYLogger.get_trace_id()
+        trace_id = SYLogger.get_trace_id() or Snowflake.id
 
         if isinstance(msg, dict) or isinstance(msg, list):
             msg_str = json.dumps(msg, ensure_ascii=False)
@@ -473,7 +473,7 @@ class SYLogger:
         request_log = {}
         if level == "ERROR":
             request_log = {
-                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
+                "trace_id": str(trace_id) if trace_id else Snowflake.id,
                 "message": msg_str,
                 "traceback": traceback.format_exc(),
                 "level": level,
@@ -481,7 +481,7 @@ class SYLogger:
             }
         else:
             request_log = {
-                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
+                "trace_id": str(trace_id) if trace_id else Snowflake.id,
                 "message": msg_str,
                 "level": level,
                 "threadName": thread_info
@@ -521,7 +521,7 @@ class SYLogger:
     @staticmethod
     def exception(msg: any, *args, **kwargs):
         """记录异常信息，包括完整堆栈"""
-        trace_id = SYLogger.get_trace_id()
+        trace_id = SYLogger.get_trace_id() or Snowflake.id
 
         if isinstance(msg, dict) or isinstance(msg, list):
             msg_str = json.dumps(msg, ensure_ascii=False)
@@ -533,7 +533,7 @@ class SYLogger:
 
         # 构建包含异常堆栈的日志
         request_log = {
-            "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
+            "trace_id": str(trace_id) if trace_id else Snowflake.id,
             "message": msg_str,
             "level": "ERROR",
             "threadName": thread_info

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/src/sycommon/middleware/middleware.py

@@ -27,7 +27,7 @@ class Middleware:
         # app = setup_monitor_memory_middleware(app)
 
         # 设置cors
-        # app = setup_cors_handler(app)
+        app = setup_cors_handler(app)
 
         # 健康检查
         app = setup_health_handler(app)

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/src/sycommon/middleware/traceid.py

@@ -12,7 +12,7 @@ def setup_trace_id_handler(app):
         # 生成或获取 traceId
         trace_id = request.headers.get("x-traceId-header")
         if not trace_id:
-            trace_id = Snowflake.next_id()
+            trace_id = Snowflake.id
 
         # 设置 trace_id 上下文
         token = SYLogger.set_trace_id(trace_id)
@@ -101,9 +101,11 @@ def setup_trace_id_handler(app):
                 if "application/json" in content_type and not content_disposition.startswith("attachment"):
                     try:
                         data = json.loads(response_body)
-                        data["traceId"] = trace_id
-                        new_body = json.dumps(
-                            data, ensure_ascii=False).encode()
+                        new_body = response_body
+                        if data:
+                            data["traceId"] = trace_id
+                            new_body = json.dumps(
+                                data, ensure_ascii=False).encode()
 
                         # 创建新响应，确保Content-Length正确
                         response = Response(

{sycommon_python_lib-0.1.52a0 → sycommon_python_lib-0.1.55b1}/src/sycommon/services.py

@@ -23,6 +23,9 @@ class Services(metaclass=SingletonMeta):
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
+    # 用于存储待执行的异步数据库初始化任务
+    _pending_async_db_setup: List[Tuple[Callable, str]] = []
+
     def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
             Services._config = config
@@ -48,25 +51,24 @@ class Services(metaclass=SingletonMeta):
         nacos_service: Optional[Callable[[dict], None]] = None,
         logging_service: Optional[Callable[[dict], None]] = None,
         database_service: Optional[Union[
-            Tuple[Callable[[dict, str], None], str],
-            List[Tuple[Callable[[dict, str], None], str]]
+            Tuple[Callable, str],
+            List[Tuple[Callable, str]]
         ]] = None,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
         rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
     ) -> FastAPI:
         load_dotenv()
-        # 保存应用实例和配置
         cls._app = app
         cls._config = config
         cls._user_lifespan = app.router.lifespan_context
-        # 设置文档
+
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
-        # 设置app.state host, port
+
         if not cls._config:
             config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
             cls._config = config
-        # 使用config
+
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
             "port": cls._config.get('Port', 8080),
@@ -74,7 +76,6 @@ class Services(metaclass=SingletonMeta):
             "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 10)
         }
 
-        # 立即配置非异步服务（在应用启动前）
         if middleware:
             middleware(app, config)
 
@@ -84,25 +85,62 @@ class Services(metaclass=SingletonMeta):
         if logging_service:
             logging_service(config)
 
+        # ========== 处理数据库服务 ==========
+        # 清空之前的待执行列表（防止热重载时重复）
+        cls._pending_async_db_setup = []
+
         if database_service:
-            cls._setup_database_static(database_service, config)
+            # 解析配置并区分同步/异步
+            items = [database_service] if isinstance(
+                database_service, tuple) else database_service
+            for item in items:
+                db_setup_func, db_name = item
+                if asyncio.iscoroutinefunction(db_setup_func):
+                    # 如果是异步函数，加入待执行列表
+                    logging.info(f"检测到异步数据库服务: {db_name}，将在应用启动时初始化")
+                    cls._pending_async_db_setup.append(item)
+                else:
+                    # 如果是同步函数，立即执行
+                    logging.info(f"执行同步数据库服务: {db_name}")
+                    try:
+                        db_setup_func(config, db_name)
+                    except Exception as e:
+                        logging.error(
+                            f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
 
         # 创建组合生命周期管理器
         @asynccontextmanager
         async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             # 1. 执行Services自身的初始化
             instance = cls(config, app)
-            has_listeners = bool(
+
+            # ========== 执行挂起的异步数据库初始化 ==========
+            if cls._pending_async_db_setup:
+                logging.info("开始执行异步数据库初始化...")
+                for db_setup_func, db_name in cls._pending_async_db_setup:
+                    try:
+                        await db_setup_func(config, db_name)
+                        logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                    except Exception as e:
+                        logging.error(
+                            f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
+
+            # ========== 初始化 MQ ==========
+            has_valid_listeners = bool(
                 rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-            has_senders = bool(rabbitmq_senders and len(rabbitmq_senders) > 0)
+            has_valid_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             try:
-                await instance._setup_mq_async(
-                    rabbitmq_listeners=rabbitmq_listeners,
-                    rabbitmq_senders=rabbitmq_senders,
-                    has_listeners=has_listeners,
-                    has_senders=has_senders
-                )
+                if has_valid_listeners or has_valid_senders:
+                    await instance._setup_mq_async(
+                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                        has_listeners=has_valid_listeners,
+                        has_senders=has_valid_senders
+                    )
                 cls._initialized = True
                 logging.info("Services初始化完成")
             except Exception as e:
@@ -114,28 +152,18 @@ class Services(metaclass=SingletonMeta):
             # 2. 执行用户定义的生命周期
             if cls._user_lifespan:
                 async with cls._user_lifespan(app):
-                    yield  # 应用运行阶段
+                    yield
             else:
-                yield  # 没有用户生命周期时直接 yield
+                yield
 
             # 3. 执行Services的关闭逻辑
             await cls.shutdown()
             logging.info("Services已关闭")
 
-        # 设置组合生命周期
         app.router.lifespan_context = combined_lifespan
-
         return app
 
-    @staticmethod
-    def _setup_database_static(database_service, config):
-        """静态方法：设置数据库服务"""
-        if isinstance(database_service, tuple):
-            db_setup, db_name = database_service
-            db_setup(config, db_name)
-        elif isinstance(database_service, list):
-            for db_setup, db_name in database_service:
-                db_setup(config, db_name)
+    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
 
     async def _setup_mq_async(
         self,
@@ -144,11 +172,13 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务（适配单通道RabbitMQService）"""
-        # 初始化RabbitMQ服务，传递状态
+        """异步设置MQ相关服务"""
+        if not (has_listeners or has_senders):
+            logging.info("无RabbitMQ监听器/发送器配置，跳过RabbitMQService初始化")
+            return
+
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
-        # 优化：等待连接池“存在且初始化完成”（避免提前执行后续逻辑）
         start_time = asyncio.get_event_loop().time()
         while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
             if asyncio.get_event_loop().time() - start_time > 30:
@@ -156,42 +186,33 @@ class Services(metaclass=SingletonMeta):
             logging.info("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
-        # 设置发送器，传递是否有监听器的标志
-        if rabbitmq_senders:
-            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
-            if rabbitmq_listeners:
+        if has_senders and rabbitmq_senders:
+            if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
                     for listener in rabbitmq_listeners:
                         if sender.queue_name == listener.queue_name:
                             sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
-        # 设置监听器，传递是否有发送器的标志
-        if rabbitmq_listeners:
+        if has_listeners and rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
-        # 验证初始化结果
         if has_listeners:
-            # 异步获取客户端数量（适配新的RabbitMQService）
-            listener_count = len(
-                RabbitMQService._consumer_tasks)
+            listener_count = len(RabbitMQService._consumer_tasks)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
                 logging.warning("未成功初始化任何监听器，请检查配置或MQ服务状态")
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
-        """设置发送器（适配新的RabbitMQService异步方法）"""
+        """设置发送器"""
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
-
-        # 将是否有监听器的信息传递给RabbitMQService（异步调用）
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
-        # 更新已注册的发送器（从RabbitMQService获取实际注册的名称）
         Services._registered_senders = RabbitMQService._sender_client_names
         logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
-        """设置监听器（适配新的RabbitMQService异步方法）"""
+        """设置监听器"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -202,7 +223,7 @@ class Services(metaclass=SingletonMeta):
         max_retries: int = 3,
         retry_delay: float = 1.0, **kwargs
     ) -> None:
-        """发送消息，添加重试机制（适配单通道RabbitMQService）"""
+        """发送消息"""
         if not cls._initialized or not cls._loop:
             logging.error("Services not properly initialized!")
             raise ValueError("服务未正确初始化")
@@ -213,18 +234,15 @@ class Services(metaclass=SingletonMeta):
 
         for attempt in range(max_retries):
             try:
-                # 验证发送器是否注册
                 if queue_name not in cls._registered_senders:
                     cls._registered_senders = RabbitMQService._sender_client_names
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
-                # 获取发送器（适配新的异步get_sender方法）
                 sender = await RabbitMQService.get_sender(queue_name)
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
 
-                # 发送消息（调用RabbitMQService的异步send_message）
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
@@ -234,25 +252,18 @@ class Services(metaclass=SingletonMeta):
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
-
                 logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
-                    f"{retry_delay}秒后重试..."
-                )
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，{retry_delay}秒后重试...")
                 await asyncio.sleep(retry_delay)
 
     @classmethod
     async def shutdown(cls):
-        """关闭所有服务（适配单通道RabbitMQService关闭逻辑）"""
+        """关闭所有服务"""
         async with cls._shutdown_lock:
             if RabbitMQService._is_shutdown:
                 logging.info("RabbitMQService已关闭，无需重复操作")
                 return
-
-            # 关闭RabbitMQ服务（异步调用，内部会关闭所有客户端+消费任务）
             await RabbitMQService.shutdown()
-
-            # 清理全局状态
             cls._initialized = False
             cls._registered_senders.clear()
             logging.info("所有服务已关闭")