refactor: 重构底层代码，抽离conn，调整消息处理器并创建传输层接口。

feature: 支持mqtt非桥接版本。

main/xiaozhi-server/core/services/connection_service.py

@@ -0,0 +1,161 @@
+import asyncio
+from typing import Dict, Any
+from urllib.parse import parse_qs, urlparse
+
+from core.context.session_context import SessionContext
+from core.transport.transport_interface import TransportInterface
+from core.components.component_registry import ComponentRegistry
+from core.components.component_manager import ComponentType
+from core.pipeline.message_pipeline import MessagePipeline
+from core.processors.message_router import MessageRouter
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class ConnectionService:
+    """连接服务：统一管理连接生命周期，替代ConnectionHandler"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.logger = setup_logging()
+        
+        # 创建统一消息路由器
+        self.message_router = MessageRouter()
+        
+        # 创建消息处理管道
+        self.message_pipeline = MessagePipeline()
+        self._setup_pipeline()
+    
+    def _setup_pipeline(self):
+        """设置消息处理管道"""
+        # 使用统一的MessageRouter替代单独的processor
+        self.message_pipeline.add_processor(self.message_router)
+    
+    async def handle_connection(self, transport: TransportInterface, headers: Dict[str, str]):
+        """处理新连接"""
+        # 创建会话上下文
+        context = SessionContext()
+        context.config = self.config
+        context.headers = headers
+        
+        # 设置transport接口
+        context.transport = transport
+        
+        # 兼容性：设置websocket属性（如果transport是WebSocket）
+        if hasattr(transport, '_websocket'):
+            context.websocket = transport._websocket
+        
+        # 从headers或URL参数中提取设备信息
+        await self._extract_device_info(context, headers)
+        
+        # 创建组件管理器
+        component_manager = ComponentRegistry.create_component_manager(self.config)
+        
+        # 启动超时检查任务
+        timeout_task = None
+        
+        try:
+            logger.info(f"新连接建立: {context.device_id} from {context.client_ip}")
+            
+            # 初始化必要的组件
+            await self._initialize_components(context, component_manager)
+            
+            # 启动超时检查
+            timeout_task = asyncio.create_task(self._check_timeout(context, transport))
+            
+            # 处理消息流
+            async for message in transport.receive():
+                try:
+                    await self.message_pipeline.process_message(context, transport, message)
+                except Exception as e:
+                    logger.error(f"处理消息时出错: {e}")
+                    # 继续处理其他消息，不中断连接
+                    
+        except Exception as e:
+            logger.error(f"连接处理出错: {e}")
+        finally:
+            # 清理资源
+            if timeout_task and not timeout_task.done():
+                timeout_task.cancel()
+                try:
+                    await timeout_task
+                except asyncio.CancelledError:
+                    pass
+            
+            # 清理组件
+            try:
+                await component_manager.cleanup_all()
+            except Exception as e:
+                logger.error(f"组件清理失败: {e}")
+            
+            # 执行会话清理回调
+            try:
+                await context.run_cleanup()
+            except Exception as e:
+                logger.error(f"会话清理失败: {e}")
+            
+            # 关闭传输层
+            try:
+                await transport.close()
+            except Exception as e:
+                logger.error(f"关闭传输层失败: {e}")
+            
+            logger.info(f"连接已关闭: {context.device_id}")
+    
+    async def _extract_device_info(self, context: SessionContext, headers: Dict[str, str]):
+        """从headers或URL参数中提取设备信息"""
+        device_id = headers.get("device-id")
+        client_id = headers.get("client-id")
+        
+        # 如果headers中没有device-id，尝试从URL参数中获取
+        if not device_id:
+            # 这里需要从WebSocket请求中获取路径信息
+            # 暂时使用占位符，后续在WebSocketServer中传入
+            pass
+        
+        context.device_id = device_id
+        context.client_ip = headers.get("x-real-ip") or headers.get("x-forwarded-for", "unknown")
+        
+        if context.client_ip and "," in context.client_ip:
+            context.client_ip = context.client_ip.split(",")[0].strip()
+    
+    async def _initialize_components(self, context: SessionContext, component_manager):
+        """初始化必要的组件"""
+        try:
+            # 设置组件管理器到上下文
+            context.component_manager = component_manager
+            
+            # 根据配置确定需要初始化的组件
+            required_components = ComponentRegistry.get_required_components(self.config)
+            
+            # 按需初始化组件
+            for component_type in required_components:
+                component = await component_manager.get_component(component_type, context)
+                if component:
+                    logger.info(f"组件初始化成功: {component_type.value}")
+                else:
+                    logger.warning(f"组件初始化失败: {component_type.value}")
+            
+        except Exception as e:
+            logger.error(f"组件初始化出错: {e}")
+            raise
+    
+    async def _check_timeout(self, context: SessionContext, transport: TransportInterface):
+        """定期检查连接超时"""
+        timeout_seconds = context.config.get("close_connection_no_voice_time", 120)
+        check_interval = min(30, timeout_seconds // 4)  # 检查间隔为超时时间的1/4，最多30秒
+        
+        try:
+            while transport.is_connected:
+                await asyncio.sleep(check_interval)
+                
+                if context.is_timeout(timeout_seconds):
+                    logger.info(f"连接超时，关闭连接: {context.session_id}")
+                    await transport.close()
+                    break
+                    
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"超时检查出错: {e}")