mqttxx 2.0.2__py3-none-any.whl → 3.1.2__py3-none-any.whl

mqttxx/__init__.py

@@ -3,21 +3,25 @@
 提供：
 - MQTTClient: MQTT 连接管理（自动重连、订阅队列化、TLS/SSL 支持）
 - RPCManager: 双向对等 RPC 调用（超时控制、权限检查、并发限制）
+- EventChannelManager: 高吞吐事件广播通道（单向、无返回值）
 - 配置对象: MQTTConfig, TLSConfig, AuthConfig, RPCConfig 等
-- 协议定义: RPCRequest, RPCResponse
+- 协议定义: RPCRequest, RPCResponse, EventMessage
 - 异常系统: 统一错误码和异常层次
 """
 
-__version__ = "2.0.0"
+__version__ = "3.1.0"
 __author__ = "MQTTX Team"
 
 # 核心客户端
-from .client import MQTTClient
+from .client import MQTTClient, RawAPI
 
 # RPC 管理器
 from .rpc import RPCManager
 from .conventions import ConventionalRPCManager
 
+# Event Channel 管理器
+from .events import EventChannelManager, EventMessage
+
 # 配置对象
 from .config import (
     MQTTConfig,
@@ -31,7 +35,7 @@ from .config import (
 from .protocol import (
     RPCRequest,
     RPCResponse,
-    parse_message,
+    # parse_message 是内部 API，不再导出
 )
 
 # 异常系统
@@ -54,9 +58,13 @@ from .exceptions import (
 __all__ = [
     # MQTT 客户端
     "MQTTClient",
+    "RawAPI",  # Raw API (逃生通道)
     # RPC 管理器
     "RPCManager",
     "ConventionalRPCManager",  # 约定式 RPC（强约束系统）
+    # Event Channel 管理器
+    "EventChannelManager",
+    "EventMessage",
     # 配置对象
     "MQTTConfig",
     "TLSConfig",
@@ -66,7 +74,7 @@ __all__ = [
     # 协议定义
     "RPCRequest",
     "RPCResponse",
-    "parse_message",
+    # parse_message 已移除 - 内部 API
     # 异常系统
     "ErrorCode",
     "MQTTXError",

mqttxx/client.py

@@ -1,15 +1,166 @@
 # aiomqtt 高级封装 - 基于纯 async/await 架构
 
 import asyncio
-import json
+import os
 import ssl
-from typing import Callable, Optional
+from typing import Callable, Optional, Any, TYPE_CHECKING
 from loguru import logger
 import aiomqtt
+from paho.mqtt.matcher import MQTTMatcher
 
 from .config import MQTTConfig
-from .exceptions import MessageError
-from .protocol import parse_message
+
+if TYPE_CHECKING:
+    from .client import MQTTClient
+
+
+class RawAPI:
+    """Raw MQTT API (逃生通道)
+
+    绕过协议层，直接操作 bytes。
+
+    警告:
+        这是逃生通道，仅在以下场景使用:
+        - 自定义协议 (非 JSON/RPC)
+        - 性能敏感场景 (避免编解码)
+        - 与第三方系统集成
+
+    示例:
+        # 订阅原始 bytes
+        client.raw.subscribe("sensor/+", lambda t, b: process(b))
+
+        # 发布原始 bytes
+        await client.raw.publish("topic", b"\\x01\\x02\\x03")
+    """
+
+    def __init__(self, client: "MQTTClient"):
+        """初始化 Raw API
+
+        Args:
+            client: MQTTClient 实例
+        """
+        self._client = client
+
+    def subscribe(self, pattern: str, handler: Callable[[str, bytes], Any]):
+        """订阅原始消息 (bytes)
+
+        Args:
+            pattern: MQTT topic pattern (支持通配符 +/#)
+            handler: 回调函数
+                - 签名: async def handler(topic: str, payload: bytes)
+                - topic: 实际收到消息的 topic
+                - payload: 原始 bytes 数据 (未解码)
+
+        并发行为:
+            - 同一 pattern 的多个 handlers 按注册顺序**顺序调用**（非并发）
+            - 如需并发处理，请在 handler 内部使用 asyncio.create_task()
+
+        示例:
+            # 基础用法
+            async def on_message(topic: str, payload: bytes):
+                data = json.loads(payload.decode('utf-8'))
+                print(f"收到消息: {topic} -> {data}")
+
+            client.raw.subscribe("sensor/+/data", on_message)
+
+            # 顺序处理（默认）
+            async def handler_seq(topic: str, payload: bytes):
+                await process_data(payload)  # 阻塞后续 handlers
+
+            # 并发处理（手动）
+            async def handler_async(topic: str, payload: bytes):
+                asyncio.create_task(process_async(payload))  # 不阻塞
+        """
+        # 追踪 handlers (辅助结构)
+        if pattern not in self._client._raw_handlers:
+            self._client._raw_handlers[pattern] = []
+        self._client._raw_handlers[pattern].append(handler)
+
+        # 同步到 MQTTMatcher (核心匹配引擎)
+        self._client._raw_matcher[pattern] = self._client._raw_handlers[pattern]
+
+        # 订阅 MQTT topic
+        self._client._subscriptions.add(pattern)
+        if self._client._client:
+            asyncio.create_task(self._client._do_subscribe(pattern))
+        else:
+            logger.info(f"Raw 订阅已队列化 (等待连接) - pattern: {pattern}")
+
+        logger.debug(f"Raw 订阅成功 - pattern: {pattern}")
+
+    async def publish(self, topic: str, payload: bytes, qos: int = 0):
+        """发布原始消息 (bytes)
+
+        Args:
+            topic: 目标主题
+            payload: 消息载荷 (bytes)
+            qos: QoS 等级 (0/1/2)
+
+        异常:
+            aiomqtt.MqttError: 发布失败
+        """
+        if not self._client._client:
+            logger.warning(f"发布失败：客户端未连接 - topic: {topic}")
+            return
+
+        try:
+            await self._client._client.publish(topic, payload, qos=qos)
+        except aiomqtt.MqttError as e:
+            logger.error(f"发布失败 - topic: {topic}, error: {e}")
+
+    def unsubscribe(self, pattern: str, handler: Optional[Callable] = None):
+        """取消订阅（修复 P0-B）
+
+        Args:
+            pattern: MQTT topic pattern
+            handler: 要移除的 handler（None = 移除所有）
+
+        示例:
+            # 移除特定 handler
+            client.raw.unsubscribe("test/+", my_handler)
+
+            # 移除所有 handler
+            client.raw.unsubscribe("test/+")
+        """
+        if pattern not in self._client._raw_handlers:
+            logger.debug(f"Raw 取消订阅失败：pattern 不存在 - {pattern}")
+            return
+
+        if handler is None:
+            # 移除所有 handler
+            del self._client._raw_handlers[pattern]
+            del self._client._raw_matcher[pattern]
+            self._client._subscriptions.discard(pattern)
+
+            # 发送 MQTT UNSUBSCRIBE
+            if self._client._client:
+                asyncio.create_task(self._client._client.unsubscribe(pattern))
+
+            logger.debug(f"Raw 取消订阅（全部）- pattern: {pattern}")
+        else:
+            # 移除特定 handler
+            handlers = self._client._raw_handlers[pattern]
+            if handler in handlers:
+                handlers.remove(handler)
+
+                # 如果没有 handler 了，完全取消订阅
+                if not handlers:
+                    del self._client._raw_handlers[pattern]
+                    del self._client._raw_matcher[pattern]
+                    self._client._subscriptions.discard(pattern)
+
+                    if self._client._client:
+                        asyncio.create_task(self._client._client.unsubscribe(pattern))
+
+                    logger.debug(
+                        f"Raw 取消订阅（全部，最后一个 handler）- pattern: {pattern}"
+                    )
+                else:
+                    logger.debug(
+                        f"Raw 取消订阅（部分）- pattern: {pattern}, 剩余 {len(handlers)} 个 handler"
+                    )
+            else:
+                logger.debug(f"Raw 取消订阅失败：handler 不存在 - pattern: {pattern}")
 
 
 class MQTTClient:
@@ -19,6 +170,35 @@ class MQTTClient:
     - aiomqtt 基于 paho-mqtt 封装，成熟稳定
     - 不自动重连，需要手动实现重连循环（官方推荐模式）
     - 使用 `async for message in client.messages` 异步迭代器
+
+    设计约束:
+        - **单 Event Loop 设计**: 所有方法（subscribe/unsubscribe/handler）
+          必须在同一个 asyncio event loop 中调用
+        - **不支持多线程/多 loop 并发**: 如果需要在多个线程中使用，
+          请为每个线程创建独立的 MQTTClient 实例
+
+    并发安全:
+        - ✅ 单 loop 内并发调用 subscribe/unsubscribe：安全
+
+    示例:
+        # ✅ 正确：单 loop
+        async def main():
+            client = MQTTClient(config)
+            await client.connect()
+            client.raw.subscribe("topic", handler1)  # 安全
+            client.raw.subscribe("topic", handler2)  # 安全
+
+        # ❌ 错误：多线程
+        def thread1():
+            client.raw.subscribe("topic", handler1)  # 不安全
+
+        def thread2():
+            client.raw.subscribe("topic", handler2)  # 不安全
+
+        # ✅ 正确：多线程各自创建实例
+        def thread1():
+            client1 = MQTTClient(config)
+            asyncio.run(client1.connect())
     """
 
     def __init__(self, config: MQTTConfig):
@@ -33,12 +213,29 @@ class MQTTClient:
         self.config = config
         self._client: Optional[aiomqtt.Client] = None
         self._subscriptions: set[str] = set()  # 订阅列表（用于重连恢复）
-        self._message_handlers: dict[str, Callable] = {}  # topic → handler 映射
+
+        # Raw 订阅（使用 MQTTMatcher 进行通配符匹配）
+        # _raw_matcher 是核心匹配引擎（用于 iter_match）
+        # _raw_handlers 是辅助追踪结构（因 MQTTMatcher 不支持 getitem/contains）
+        self._raw_matcher = MQTTMatcher()
+        self._raw_handlers: dict[str, list[Callable]] = {}
+
         self._running = False
         self._connected = False  # 修复 P0-2：真实连接状态标志
         self._reconnect_task: Optional[asyncio.Task] = None
         self._message_task: Optional[asyncio.Task] = None
 
+        # 消息处理队列和 Workers（修复 P0-A）
+        self._message_queue: asyncio.Queue = asyncio.Queue(
+            maxsize=config.message_queue_maxsize
+        )
+        self._workers: list[asyncio.Task] = []
+        # Worker 数量：默认 CPU核数×2（IO-bound 最优）
+        self._num_workers = config.num_workers or (os.cpu_count() or 1) * 2
+
+        # Raw API (逃生通道)
+        self._raw_api = RawAPI(self)
+
     async def connect(self):
         """连接到 MQTT Broker
 
@@ -51,6 +248,12 @@ class MQTTClient:
 
         self._running = True
 
+        # 启动消息处理
+        for i in range(self._num_workers):
+            worker = asyncio.create_task(self._worker(i), name=f"mqtt_worker_{i}")
+            self._workers.append(worker)
+            logger.info(f"MQTT 已启动 {self._num_workers} 个消息处理 worker")
+
         self._reconnect_task = asyncio.create_task(
             self._reconnect_loop(), name="mqtt_reconnect"
         )
@@ -60,6 +263,15 @@ class MQTTClient:
         self._running = False
         self._connected = False  # 修复 P0-2：标记为未连接
 
+        # 等待 workers 处理完队列（修复 P0-A）
+        if self._workers:
+            # 等待所有 workers 完成（最多 5 秒）
+            _, pending = await asyncio.wait(self._workers, timeout=5.0)
+            # 取消未完成的 workers
+            for w in pending:
+                w.cancel()
+            self._workers.clear()
+
         # 取消后台任务
         if self._reconnect_task:
             self._reconnect_task.cancel()
@@ -68,15 +280,18 @@ class MQTTClient:
             except asyncio.CancelledError:
                 pass
 
-        # 取消消息处理任务
+        # 取消消息处理任务（修复 P0-D）
+        # 这会导致 _reconnect_loop 中的 async with 块退出，aiomqtt 自动清理连接
         if self._message_task:
             self._message_task.cancel()
             try:
                 await self._message_task
             except asyncio.CancelledError:
                 pass
-        if self._client:
-            self._client = None
+
+        # aiomqtt.Client 使用 async with 管理连接，退出时自动清理
+        # 不需要显式调用 disconnect()（该方法不存在）
+        self._client = None
 
         logger.info("MQTT 客户端已断开")
 
@@ -190,14 +405,14 @@ class MQTTClient:
                 await asyncio.sleep(interval)
 
     async def _message_loop(self):
-        """消息处理循环（aiomqtt 核心模式）
+        """消息接收循环（修复 P0-A：只负责接收，不处理）
 
-        使用 async for 迭代消息，替代 gmqtt 的 on_message 回调
+        使用 async for 迭代消息，将消息放入队列由 workers 处理
 
-        关键特性：
-        - 非阻塞：异步迭代器自动 yield 控制权
-        - 顺序处理：每条消息按顺序处理
-        - 并发处理：每条消息在独立 Task 中处理（不阻塞迭代器）
+        关键改进：
+        - 接收和处理分离：避免高吞吐下任务爆炸
+        - 有界队列：maxsize 可配置（默认 100k），作为保险丝
+        - 队列满时阻塞：形成自然背压，CPU/延迟会变明显（扩容信号）
 
         异常处理：
         - asyncio.CancelledError：任务被取消，退出循环
@@ -208,19 +423,9 @@ class MQTTClient:
             return
 
         try:
-            # region 调用代码溯源(aiomqtt.Client.messages)
-            # aiomqtt.Client.messages 是一个异步迭代器
-            # 内部调用：
-            #   paho.mqtt.client.Client._handle_on_message()
-            #   → 将消息放入队列
-            #   → aiomqtt 从队列中取出消息
-            # GitHub：https://github.com/sbtinstruments/aiomqtt/blob/main/aiomqtt/client.py#L400
-            # endregion
             async for message in self._client.messages:
-                # 异步处理消息（不阻塞迭代器）
-                asyncio.create_task(
-                    self._handle_message(message), name=f"handle_{message.topic}"
-                )
+                # 将消息放入队列（阻塞等待，形成自然背压）
+                await self._message_queue.put(message)
         except asyncio.CancelledError:
             logger.info("消息处理任务已取消")
             raise
@@ -230,120 +435,80 @@ class MQTTClient:
         except Exception as e:
             logger.exception(f"消息循环异常: {e}")
 
-    async def _handle_message(self, message: aiomqtt.Message):
-        """处理单条消息
-        Args:
-            message: aiomqtt.Message 对象
+    async def _worker(self, worker_id: int):
+        """消息处理 Worker
 
-        消息处理流程：
-        1. 检查 payload 大小
-        2. 解码 UTF-8
-        3. 解析 JSON
-        4. 使用 protocol.parse_message() 验证和解析
-        5. 路由到对应处理器
-        """
+        从队列中取消息并处理，支持并发控制
 
-        try:
-            # 检查 payload 大小（防御 DoS）
-            if len(message.payload) > self.config.max_payload_size:
-                logger.warning(
-                    f"Payload 过大，已忽略 - "
-                    f"topic: {message.topic}, size: {len(message.payload)}"
-                )
-                return
+        Args:
+            worker_id: Worker ID（用于日志）
 
+        设计要点：
+        - 并发上限可控（默认 16 个 worker）
+        - 异常隔离（worker 崩溃不影响其他 worker）
+        - 优雅退出（_running=False 时退出）
+        """
+        while self._running:
             try:
-                text = message.payload.decode("utf-8")
-                data = json.loads(text)
-            except UnicodeDecodeError as e:
-                logger.error(
-                    f"UTF-8 解码失败 - topic: {message.topic}, error: {e!r}, "
-                    f"preview: {message.payload[:100]}"
-                )
-                return
-            except json.JSONDecodeError as e:
-                logger.error(
-                    f"JSON 解析失败 - topic: {message.topic}, error: {e!r}, "
-                    f"preview: {text[:100]}"
-                )
-                return
-
-            # 解析消息类型（使用 dataclass 替代 Box）
-            msg = parse_message(data)
-
-            # 路由到对应处理器
-            topic_str = str(message.topic)
-            handler = self._message_handlers.get(topic_str)
-
-            if handler:
-                # 调用处理器
-                if asyncio.iscoroutinefunction(handler):
-                    await handler(topic_str, msg)
-                else:
-                    handler(topic_str, msg)
-            else:
-                # 修复 P0-3：RPC 请求无处理器时，立即返回错误响应（防止调用方超时）
-                from .protocol import RPCRequest, RPCResponse
-                if isinstance(msg, RPCRequest):
-                    logger.warning(
-                        f"收到 RPC 请求但无处理器 - topic: {topic_str}, method: {msg.method}"
-                    )
-                    # 立即发送错误响应
-                    error_response = RPCResponse(
-                        request_id=msg.request_id,
-                        error=f"No RPC handler registered for topic: {topic_str}"
-                    )
-                    await self.publish(msg.reply_to, json.dumps(error_response.to_dict()), qos=1)
-                else:
-                    logger.debug(f"收到消息（无处理器）- topic: {topic_str}")
-
-        except MessageError as e:
-            logger.error(f"消息解析失败: {e}")
-        except Exception as e:
-            logger.exception(f"消息处理失败: {e}")
-
-    def subscribe(self, topic: str, handler: Optional[Callable] = None):
-        """订阅主题
-
-        修复点：
-        - ✅ P0-1: 未连接时不崩溃，队列化订阅
+                # 从队列取消息（带超时，避免无法退出） asyncio.Queue 是原子安全的
+                message = await asyncio.wait_for(self._message_queue.get(), timeout=1.0)
+                # 处理消息
+                await self._handle_message(message)
+            except asyncio.TimeoutError:
+                # 队列为空，继续等待
+                continue
+            except asyncio.CancelledError:
+                logger.debug(f"Worker {worker_id} 被取消")
+                break
+            except Exception as e:
+                logger.exception(f"Worker {worker_id} 异常: {e}")
+                # 继续运行，不退出
 
-        Args:
-            topic: MQTT 主题（支持通配符 +/#）
-            handler: 消息处理器
-                签名：async def handler(topic: str, message: RPCRequest | RPCResponse)
-                或：def handler(topic: str, message: RPCRequest | RPCResponse)
+    @property
+    def raw(self) -> RawAPI:
+        """访问 Raw MQTT API (逃生通道)
 
-        设计决策：
-        - 记录订阅到 _subscriptions set（用于重连恢复）
-        - 如果已连接，立即订阅
-        - 如果未连接，等待连接后自动订阅
+        Returns:
+            RawAPI 实例
 
         示例:
-            # 同步处理器
-            def my_handler(topic, message):
-                print(f"收到消息: {topic} - {message}")
+            client.raw.subscribe("topic", handler)
+            await client.raw.publish("topic", b"data")
+        """
+        return self._raw_api
 
-            client.subscribe("test/topic", my_handler)
+    async def _handle_message(self, message: aiomqtt.Message):
+        """处理单条消息（传输层，只处理 bytes）
 
-            # 异步处理器
-            async def my_async_handler(topic, message):
-                await process_message(message)
+        核心改变：
+        1. 不再解析 JSON/协议
+        2. 将 payload (bytes) 分发给 raw handlers
+        3. 不再区分 RPC/Event（让上层处理）
 
-            client.subscribe("test/topic", my_async_handler)
+        Args:
+            message: aiomqtt.Message 对象
         """
-        # 记录订阅（用于重连恢复）
-        self._subscriptions.add(topic)
+        topic_str = str(message.topic)
+        payload = message.payload  # bytes 类型
 
-        # 注册处理器
-        if handler:
-            self._message_handlers[topic] = handler
+        # 检查 payload 大小（防御 DoS）
+        if len(payload) > self.config.max_payload_size:
+            logger.warning(
+                f"Payload 过大，已忽略 - topic: {topic_str}, size: {len(payload)}"
+            )
+            return
 
-        # 如果已连接，立即订阅
-        if self._client:
-            asyncio.create_task(self._do_subscribe(topic))
-        else:
-            logger.info(f"订阅已队列化（等待连接）- topic: {topic}")
+        # === 唯一职责：将 bytes 分发给所有匹配的 handlers ===
+        # MQTTMatcher.iter_match 返回值列表，不是 (pattern, handlers) 元组
+        for handlers in self._raw_matcher.iter_match(topic_str):
+            for handler in handlers:
+                try:
+                    if asyncio.iscoroutinefunction(handler):
+                        await handler(topic_str, payload)  # 传递 bytes！
+                    else:
+                        handler(topic_str, payload)
+                except Exception as e:
+                    logger.exception(f"Handler 异常 - topic: {topic_str}, error: {e}")
 
     async def _do_subscribe(self, topic: str):
         """执行订阅（内部方法）
@@ -372,37 +537,15 @@ class MQTTClient:
         if not self._subscriptions:
             return
 
-        logger.info(f"恢复 {len(self._subscriptions)} 个订阅...")
+        # 创建快照，避免遍历时被修改（修复 P0-C）
+        topics = list(self._subscriptions)
+        logger.info(f"恢复 {len(topics)} 个订阅...")
 
-        for topic in self._subscriptions:
+        for topic in topics:
             await self._do_subscribe(topic)
 
         logger.success("订阅恢复完成")
 
-    async def publish(self, topic: str, payload: str, qos: int = 0):
-        """发布消息
-
-        修复点：
-        - ✅ P1-2: 未连接时记录警告
-
-        Args:
-            topic: 目标主题
-            payload: 消息载荷（字符串）
-            qos: QoS 等级（0/1/2）
-
-        异常:
-            aiomqtt.MqttError: 发布失败
-        """
-        if not self._client:
-            logger.warning(f"发布失败：客户端未连接 - topic: {topic}")
-            return
-
-        try:
-            await self._client.publish(topic, payload, qos=qos)
-            logger.debug(f"消息已发布 - topic: {topic}, qos: {qos}")
-        except aiomqtt.MqttError as e:
-            logger.error(f"发布失败 - topic: {topic}, error: {e}")
-
     def _create_tls_context(self) -> ssl.SSLContext:
         """创建 TLS 上下文
 

mqttxx/config.py

@@ -119,6 +119,16 @@ class MQTTConfig:
         reconnect: 重连配置
         max_queued_messages: 最大排队消息数（0=无限）
         max_payload_size: 最大消息载荷大小（字节，防止 DoS 攻击）
+        message_queue_maxsize: 消息队列大小限制（默认 100,000）
+            - 语义："几乎无限"，仅作保险丝防止 OOM
+            - 队列满时行为：阻塞等待（背压信号）
+            - 触发背压时：CPU/延迟升高 → 扩容信号
+            - Python 字面量分隔符：100_000 = 100000（下划线仅用于可读性）
+        num_workers: Worker 数量（默认 None = CPU核数×2）
+            - None（默认）：CPU核数 × 2（适合 IO-bound 负载）
+            - 自定义值：根据 handler 类型调整
+                - CPU-bound handler：设为 CPU核数
+                - IO-bound handler：设为 CPU核数 × 2~4
         log_level: 日志级别（DEBUG|INFO|WARNING|ERROR）
 
     示例:
@@ -165,6 +175,10 @@ class MQTTConfig:
     max_queued_messages: int = 0  # 0 = 无限
     max_payload_size: int = 1024 * 1024  # 1MB
 
+    # 消息处理（修复 P0-A）
+    message_queue_maxsize: int = 100_000  # 10W 条 队列最大容量（保险丝）
+    num_workers: Optional[int] = None  # Worker 数量（None = CPU核数×2）
+
     # 日志级别
     log_level: str = "INFO"
 

mqttxx/conventions.py

@@ -1,11 +1,12 @@
 # 约定式 RPC 管理器 - 去角色设计
 
-from typing import Any, Optional
+from typing import Any, Optional, Type
 from loguru import logger
 
 from .client import MQTTClient
 from .config import RPCConfig
 from .rpc import RPCManager, AuthCallback
+from .protocol import Codec, JSONCodec
 
 
 class ConventionalRPCManager(RPCManager):
@@ -50,6 +51,7 @@ class ConventionalRPCManager(RPCManager):
         my_topic: str,
         config: Optional[RPCConfig] = None,
         auth_callback: Optional[AuthCallback] = None,
+        codec: Type[Codec] = JSONCodec,  # 新增
     ):
         """初始化约定式 RPC 管理器
 
@@ -58,9 +60,10 @@ class ConventionalRPCManager(RPCManager):
             my_topic: 本节点的 topic（自动订阅，自动注入到 reply_to）
             config: RPC 配置（可选）
             auth_callback: 权限检查回调（可选）
+            codec: 编解码器（默认 JSONCodec）
 
         自动行为：
-        - 自动订阅 my_topic
+        - 自动订阅 my_topic（接收请求和响应）
         - 自动绑定消息处理器
 
         示例:
@@ -76,12 +79,12 @@ class ConventionalRPCManager(RPCManager):
             # 多层级
             rpc = ConventionalRPCManager(client, my_topic="region/zone/device")
         """
-        super().__init__(client, config, auth_callback)
+        super().__init__(client, config, auth_callback, codec)
 
         self._my_topic = my_topic
 
-        # 自动订阅
-        client.subscribe(my_topic, self.handle_rpc_message)
+        # 自动设置（订阅响应主题）
+        self.setup(my_topic)
 
         logger.info(f"ConventionalRPCManager 已初始化 - my_topic: {my_topic}")