feat: 完善协议客户端配置创建和WebSocket传输服务集成

1. 在CellularNetworkService.StartNetworkAsync中添加协议客户端配置创建
2. 优化WebSocketTransportExtensions，移除冗余方法
3. 修正WebSocket配置文件与模型类匹配
4. 集成WebSocket传输服务到Startup
5. 重命名LogLayerHelp为ProtocolLayerConfigFactory
6. 完善错误处理和日志记录

CoreAgent.API/Configurations/websocket.Development.json

@@ -0,0 +1,11 @@
+{
+  "WebSocket": {
+    "Url": "wss://localhost:8080/ws",
+    "TimeoutMs": 15000,
+    "BatchTimeoutMs": 50,
+    "MaxBatchSize": 50,
+    "MaxReconnectAttempts": 3,
+    "QueueCapacity": 500,
+    "CacheTtlMinutes": 5
+  }
+} 

CoreAgent.API/Configurations/websocket.json

@@ -0,0 +1,11 @@
+{
+  "WebSocket": {
+    "Url": "wss://example.com/ws",
+    "TimeoutMs": 30000,
+    "BatchTimeoutMs": 100,
+    "MaxBatchSize": 100,
+    "MaxReconnectAttempts": 5,
+    "QueueCapacity": 1000,
+    "CacheTtlMinutes": 30
+  }
+} 

CoreAgent.API/Startup.cs

@@ -6,6 +6,7 @@ using CoreAgent.Infrastructure.Middleware.GlobalException;
 using CoreAgent.Domain.Models.System;
 using Microsoft.Extensions.Configuration;
 using CoreAgent.Domain.Interfaces.Network;
+using CoreAgent.WebSocketTransport.Extensions;
 
 namespace CoreAgent.API
 {
@@ -41,6 +42,9 @@ namespace CoreAgent.API
 
             // 添加网络命令配置
             services.Configure<NetworkCommandConfig>(Configuration.GetSection("networkCommand"));
+
+            // 添加 WebSocket 传输服务
+            services.AddWebSocketTransport(Configuration, "WebSocket");
         }
 
         public void Configure(IApplicationBuilder app)
@@ -87,7 +91,9 @@ namespace CoreAgent.API
                 .AddJsonFile($"{configurationsDirectory}/api-versioning.json", optional: false, reloadOnChange: true)
                 .AddJsonFile($"{configurationsDirectory}/api-versioning.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
                 .AddJsonFile($"{configurationsDirectory}/netcommand.json", optional: false, reloadOnChange: true)
-                .AddJsonFile($"{configurationsDirectory}/netcommand.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
+                .AddJsonFile($"{configurationsDirectory}/netcommand.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
+                .AddJsonFile($"{configurationsDirectory}/websocket.json", optional: false, reloadOnChange: true)
+                .AddJsonFile($"{configurationsDirectory}/websocket.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
 
             // 添加配置
             builder.Services.Configure<AppSettings>(builder.Configuration);

CoreAgent.Infrastructure/Services/Network/CellularNetworkService.cs

@@ -5,6 +5,7 @@ using CoreAgent.Domain.Interfaces.Network;
 using CoreAgent.Domain.Interfaces.System.Command;
 using CoreAgent.Domain.Models.Network;
 using CoreAgent.Domain.Models.System;
+using CoreAgent.Infrastructure.Services.Network;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.IO;
@@ -17,6 +18,7 @@ namespace CoreAgent.Infrastructure.Services.Network;
 public class CellularNetworkService : ICellularNetworkService
 {
     private readonly ILogger<CellularNetworkService> _logger;
+    private readonly ILoggerFactory _loggerFactory;
     private readonly ISystemCommandExecutor _commandExecutor;
     private readonly INetworkConfigurationService _configService;
     private readonly ICellularNetworkContext _context;
@@ -29,6 +31,7 @@ public class CellularNetworkService : ICellularNetworkService
 
     public CellularNetworkService(
         ILogger<CellularNetworkService> logger,
+        ILoggerFactory loggerFactory,
         ISystemCommandExecutor commandExecutor,
         INetworkConfigurationService configService,
         ICellularNetworkContext context,
@@ -37,6 +40,7 @@ public class CellularNetworkService : ICellularNetworkService
         INetworkStatusMonitor statusMonitor)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
         _commandExecutor = commandExecutor ?? throw new ArgumentNullException(nameof(commandExecutor));
         _configService = configService ?? throw new ArgumentNullException(nameof(configService));
         _context = context ?? throw new ArgumentNullException(nameof(context));
@@ -107,52 +111,6 @@ public class CellularNetworkService : ICellularNetworkService
         }
     }
 
-    /// <summary>
-    /// 检查网络状态
-    /// </summary>
-    /// <param name="newConfigKey">新的网络配置键</param>
-    /// <returns>检查结果</returns>
-    private CellularNetworkOperationResult CheckNetworkState(string newConfigKey)
-    {
-        try
-        {
-            // 获取当前网络状态
-            var currentKey = _context.GetNeConfigKey();
-            var currentState = _context.GetNetworkState();
-
-            // 检查是否已初始化
-            if (!string.IsNullOrEmpty(currentKey))
-            {
-                // 检查是否是相同的配置
-                if (currentKey == newConfigKey)
-                {
-                    // 检查当前状态
-                    if (currentState.CurrentStatus == NetworkStatus.Connected)
-                    {
-                        return CellularNetworkOperationResult.Failure("当前网络配置已经处于连接状态");
-                    }
-                }
-                else
-                {
-                    // 检查当前网络状态
-                    if (currentState.CurrentStatus == NetworkStatus.Connected)
-                    {
-                        var message = $"检测到不同的网络配置，当前运行配置: {currentKey}，新配置: {newConfigKey}，请先停止当前网络";
-                        _logger.LogWarning(message);
-                        return CellularNetworkOperationResult.Failure(message);
-                    }
-                }
-            }
-
-            return CellularNetworkOperationResult.Success(NetworkStatus.Unknown);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "检查网络状态失败");
-            return CellularNetworkOperationResult.Failure($"检查网络状态失败: {ex.Message}");
-        }
-    }
-
     /// <summary>
     /// 停止蜂窝网络
     /// </summary>
@@ -233,6 +191,52 @@ public class CellularNetworkService : ICellularNetworkService
         }
     }
 
+    /// <summary>
+    /// 检查网络状态
+    /// </summary>
+    /// <param name="newConfigKey">新的网络配置键</param>
+    /// <returns>检查结果</returns>
+    private CellularNetworkOperationResult CheckNetworkState(string newConfigKey)
+    {
+        try
+        {
+            // 获取当前网络状态
+            var currentKey = _context.GetNeConfigKey();
+            var currentState = _context.GetNetworkState();
+
+            // 检查是否已初始化
+            if (!string.IsNullOrEmpty(currentKey))
+            {
+                // 检查是否是相同的配置
+                if (currentKey == newConfigKey)
+                {
+                    // 检查当前状态
+                    if (currentState.CurrentStatus == NetworkStatus.Connected)
+                    {
+                        return CellularNetworkOperationResult.Failure("当前网络配置已经处于连接状态");
+                    }
+                }
+                else
+                {
+                    // 检查当前网络状态
+                    if (currentState.CurrentStatus == NetworkStatus.Connected)
+                    {
+                        var message = $"检测到不同的网络配置，当前运行配置: {currentKey}，新配置: {newConfigKey}，请先停止当前网络";
+                        _logger.LogWarning(message);
+                        return CellularNetworkOperationResult.Failure(message);
+                    }
+                }
+            }
+
+            return CellularNetworkOperationResult.Success(NetworkStatus.Unknown);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "检查网络状态失败");
+            return CellularNetworkOperationResult.Failure($"检查网络状态失败: {ex.Message}");
+        }
+    }
+
     private async Task<CellularNetworkOperationResult> StartNetworkAsync(string key)
     {
         // 1. 获取并验证网络配置
@@ -272,6 +276,19 @@ public class CellularNetworkService : ICellularNetworkService
         // 5. 更新 IP 端点管理器
         _context.NetworkIPEndPointManager.UpdateEndPoints(endPoints);
 
+        // 5.5. 创建协议客户端配置
+        var protocolConfigFactory = new ProtocolClientConfigFactory(_loggerFactory.CreateLogger<ProtocolClientConfigFactory>(), _context);
+        var configCreated = protocolConfigFactory.CreateFromEntities();
+        if (configCreated)
+        {
+            _logger.LogInformation("协议客户端配置创建成功，共创建 {ConfigCount} 个配置", protocolConfigFactory.ConfigCount);
+        }
+        else
+        {
+            _logger.LogWarning("协议客户端配置创建失败");
+            return CellularNetworkOperationResult.Failure("协议客户端配置创建失败");
+        }
+
         // 6. 启动网络配置
         _logger.LogInformation("正在启动蜂窝网络配置: {ConfigKey}", key);
         var enableResult = await _interfaceManager.EnableAsync(config);
@@ -301,6 +318,7 @@ public class CellularNetworkService : ICellularNetworkService
         var state = _context.GetNetworkState();
         state.MarkAsStarted();
         _logger.LogInformation("蜂窝网络配置 {ConfigKey} 启动成功，当前状态: {Status}", key, state.CurrentStatus);
+
         return CellularNetworkOperationResult.Success(state.CurrentStatus);
     }
 }

CoreAgent.Infrastructure/Services/Network/ProtocolClientConfigFactory.cs

@@ -1,5 +1,7 @@
+using CoreAgent.Domain.Interfaces.Network;
 using CoreAgent.ProtocolClient.Models;
 using Microsoft.Extensions.Logging;
+using System.Linq;
 
 namespace CoreAgent.Infrastructure.Services.Network
 {
@@ -12,33 +14,148 @@ namespace CoreAgent.Infrastructure.Services.Network
         private readonly ILogger<ProtocolClientConfigFactory> _logger;
         private readonly List<ProtocolClientConfig> _configs;
 
-        public ProtocolClientConfigFactory(ILogger<ProtocolClientConfigFactory> logger)
+          private readonly ICellularNetworkContext _context;
+
+        public ProtocolClientConfigFactory(ILogger<ProtocolClientConfigFactory> logger,ICellularNetworkContext context)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _configs = new List<ProtocolClientConfig>();
+            _context = context ?? throw new ArgumentNullException(nameof(context));
         }
 
         /// <summary>
         /// 从多个实体创建协议客户端配置数组
         /// </summary>
-        /// <param name="entities">实体列表</param>
-        /// <returns>协议客户端配置数组</returns>
-        public ProtocolClientConfig[] CreateFromEntities(IEnumerable<object> entities)
+        /// <returns>是否成功创建配置</returns>
+        public bool CreateFromEntities()
+        {
+            try
+            {
+                _logger.LogInformation("开始从多个实体创建协议客户端配置数组");
+
+                // 清空现有配置
+                _configs.Clear();
+
+                // 处理RAN端点
+                ProcessRanEndPoint();
+
+                // 处理IMS端点
+                ProcessImsEndPoints();
+
+                // 处理CN端点
+                //ProcessCnEndPoints();
+
+                _logger.LogInformation("协议客户端配置创建完成，共创建 {Count} 个配置", _configs.Count);
+                return _configs.Count > 0;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "创建协议客户端配置时发生异常");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 处理RAN端点配置
+        /// </summary>
+        private void ProcessRanEndPoint()
+        {
+            var ranEndPoint = _context.NetworkIPEndPointManager.GetRanEndPoint();
+            if (ranEndPoint?.ComAddr != null)
+            {
+                _configs.Add(CreateClientConfig(
+                    ranEndPoint.ComAddr, 
+                    ranEndPoint.ComAddr, 
+                    false, 
+                    "RAN", 
+                    ProtocolLayerConfigFactory.GetRANCustomLayerConfigs));
+                _logger.LogDebug("已添加RAN端点配置: {Address}", ranEndPoint.ComAddr);
+            }
+            else
+            {
+                _logger.LogWarning("RAN端点信息为空或无效");
+            }
+        }
+
+        /// <summary>
+        /// 处理IMS端点配置
+        /// </summary>
+        private void ProcessImsEndPoints()
+        {
+            var imsEndPoints = _context.NetworkIPEndPointManager.GetImsEndPoints();
+            if (imsEndPoints?.Any() == true)
+            {
+                foreach (var imsEndPoint in imsEndPoints)
+                {
+                    if (!string.IsNullOrEmpty(imsEndPoint.ComAddr))
+                    {
+                        _configs.Add(CreateClientConfig(
+                            imsEndPoint.ComAddr, 
+                            imsEndPoint.ComAddr, 
+                            false, 
+                            "IMS", 
+                            ProtocolLayerConfigFactory.GetIMSCustomLayerConfigs));
+                        _logger.LogDebug("已添加IMS端点配置: {Address}", imsEndPoint.ComAddr);
+                    }
+                    else
+                    {
+                        _logger.LogWarning("发现IMS端点配置地址为空");
+                    }
+                }
+            }
+            else
+            {
+                _logger.LogInformation("IMS端点列表为空");
+            }
+        }
+
+        /// <summary>
+        /// 处理CN端点配置
+        /// </summary>
+        private void ProcessCnEndPoints()
+        {
+            var cnEndPoints = _context.NetworkIPEndPointManager.GetCnEndPoints();
+            if (cnEndPoints?.Any() == true)
+            {
+                foreach (var cnEndPoint in cnEndPoints)
+                {
+                    if (!string.IsNullOrEmpty(cnEndPoint.ComAddr))
+                    {
+                        _configs.Add(CreateClientConfig(
+                            cnEndPoint.ComAddr, 
+                            cnEndPoint.ComAddr, 
+                            false, 
+                            "CN", 
+                            ProtocolLayerConfigFactory.GetDefaultCustomLayerConfigs));
+                        _logger.LogDebug("已添加CN端点配置: {Address}", cnEndPoint.ComAddr);
+                    }
+                    else
+                    {
+                        _logger.LogWarning("发现CN端点配置地址为空");
+                    }
+                }
+            }
+            else
+            {
+                _logger.LogInformation("CN端点列表为空");
+            }
+        }
+
+        ProtocolClientConfig CreateClientConfig(string name, string address, bool ssl, string model, Func<Dictionary<string, LogLayerConfig>> getLayers)
         {
-            // TODO: 实现从多个实体组装ProtocolClientConfig数组的逻辑
-            _logger.LogInformation("从多个实体创建协议客户端配置数组");
-            
-            // 清空现有配置
-            _configs.Clear();
-            
-            // TODO: 实现具体的组装逻辑
-            // foreach (var entity in entities)
-            // {
-            //     var config = CreateConfigFromEntity(entity);
-            //     _configs.Add(config);
-            // }
-            
-            throw new NotImplementedException("需要实现从多个实体创建协议客户端配置数组的逻辑");
+            return new ProtocolClientConfig
+            {
+                Name = name,
+                Address = address,
+                Ssl = ssl,
+                Logs = new ProtocolClientLogsConfig
+                {
+                    Signal = false,
+                    Cch = false,
+                    Layers = getLayers()
+                },
+                Model = model
+            };
         }
 
         /// <summary>

CoreAgent.ProtocolClient/Models/LogLayerHelp.cs → CoreAgent.ProtocolClient/Models/ProtocolLayerConfigFactory.cs

@@ -7,11 +7,11 @@ using System.Threading.Tasks;
 namespace CoreAgent.ProtocolClient.Models
 {
     /// <summary>
-    /// 日志层配置帮助类
+    /// 协议层日志配置工厂
     /// 提供预定义的日志层配置，用于不同协议层的日志记录控制
     /// 支持LTE协议栈各层的日志级别、大小限制和过滤规则配置
     /// </summary>
-    public static class LogLayerHelp
+    public static class ProtocolLayerConfigFactory
     {
         /// <summary>
         /// 获取默认的LTE协议层日志配置
@@ -56,5 +56,30 @@ namespace CoreAgent.ProtocolClient.Models
                 ["MMS"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = true, Filter = "debug" },
             };
         }
+
+        /// <summary>
+        /// 获取RAN协议层的日志配置
+        /// 包含PHY、MAC、RLC、PDCP、RRC、NAS等RAN相关协议的配置
+        /// </summary>
+        /// <returns>RAN协议层名称到配置的映射字典</returns>
+        public static Dictionary<string, LogLayerConfig> GetRANCustomLayerConfigs()
+        {
+            // 直接返回静态配置，避免不必要的嵌套和动态解析
+            return new Dictionary<string, LogLayerConfig>
+            {
+                ["PHY"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = true, Filter = "info" },
+                ["MAC"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = true, Filter = "info" },
+                ["RLC"] = new LogLayerConfig { Level = "info", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["PDCP"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = false, Filter = "warn" },
+                ["RRC"] = new LogLayerConfig { Level = "debug", MaxSize = 1000, Payload = true, Filter = "debug" },
+                ["NAS"] = new LogLayerConfig { Level = "debug", MaxSize = 1000, Payload = true, Filter = "debug" },
+                ["S1AP"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["NGAP"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["GTPU"] = new LogLayerConfig { Level = "info", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["X2AP"] = new LogLayerConfig { Level = "warn", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["XnAP"] = new LogLayerConfig { Level = "info", MaxSize = 1000, Payload = false, Filter = "info" },
+                ["M2AP"] = new LogLayerConfig { Level = "info", MaxSize = 1000, Payload = false, Filter = "info" }
+            };
+        }
     }
 }

CoreAgent.WebSocketTransport/Extensions/WebSocketTransportExtensions.cs

@@ -28,64 +28,50 @@ public static class WebSocketTransportExtensions
         IConfiguration configuration,
         string configSection = "WebSocket")
     {
+        if (services == null)
+            throw new ArgumentNullException(nameof(services));
+        if (configuration == null)
+            throw new ArgumentNullException(nameof(configuration));
+
         // 注册配置
         services.Configure<WebSocketConfig>(options => 
         {
             configuration.GetSection(configSection).Bind(options);
         });
-        
-        // 注册核心组件
-        services.AddSingleton<IWebSocketConnection, WebSocketConnection>();
-        services.AddSingleton<IMessageSerializer, JsonMessageSerializer>();
 
-        // 注册消息通道管理器
-        services.AddSingleton<IMessageChannelManager>(provider =>
-        {
-            var logger = provider.GetRequiredService<ILogger<MessageChannelManager>>();
-            var config = configuration.GetSection(configSection).Get<WebSocketConfig>() ?? new WebSocketConfig();
-            return new MessageChannelManager(logger, config.QueueCapacity, config.QueueCapacity, 100);
-        });
+        // 注册核心服务
+        RegisterCoreServices(services);
 
-        // 注册 WebSocket 传输
-        services.AddSingleton<IWebSocketTransport>(provider =>
-        {
-            var logger = provider.GetRequiredService<ILogger<CoreAgent.WebSocketTransport.Services.WebSocketTransport>>();
-            var connection = provider.GetRequiredService<IWebSocketConnection>();
-            var serializer = provider.GetRequiredService<IMessageSerializer>();
-            var middlewares = provider.GetServices<IMessageMiddleware>();
-            var config = configuration.GetSection(configSection).Get<WebSocketConfig>() ?? new WebSocketConfig();
-            var channelManager = provider.GetRequiredService<IMessageChannelManager>();
-            
-            return new CoreAgent.WebSocketTransport.Services.WebSocketTransport(logger, connection, serializer, middlewares, config, channelManager);
-        });
-        
         // 注册默认中间件
-        services.AddWebSocketMiddleware<LoggingMiddleware>();
-        // services.AddWebSocketMiddleware<CacheMiddleware>();
-        services.AddScoped<IMessageMiddleware>(provider =>
-        {
-            var cache = provider.GetRequiredService<IMemoryCache>();
-            var logger = provider.GetRequiredService<ILogger<CacheMiddleware>>();
-            var config = provider.GetRequiredService<IOptions<WebSocketConfig>>().Value;
-            return new CacheMiddleware(cache, logger, config);
-        });
+        RegisterDefaultMiddleware(services);
 
         return services;
     }
 
+
+
     /// <summary>
-    /// 添加 WebSocket 传输服务（使用委托配置）
+    /// 添加 WebSocket 中间件
     /// </summary>
+    /// <typeparam name="T">中间件类型</typeparam>
     /// <param name="services">服务集合</param>
-    /// <param name="configure">配置委托</param>
     /// <returns>服务集合</returns>
-    public static IServiceCollection AddWebSocketTransport(
-        this IServiceCollection services,
-        Action<WebSocketConfig> configure)
+    public static IServiceCollection AddWebSocketMiddleware<T>(this IServiceCollection services)
+        where T : class, IMessageMiddleware
+    {
+        if (services == null)
+            throw new ArgumentNullException(nameof(services));
+
+        services.AddScoped<IMessageMiddleware, T>();
+        return services;
+    }
+
+    /// <summary>
+    /// 注册核心服务
+    /// </summary>
+    /// <param name="services">服务集合</param>
+    private static void RegisterCoreServices(IServiceCollection services)
     {
-        // 注册配置
-        services.Configure<WebSocketConfig>(options => configure(options));
-        
         // 注册核心组件
         services.AddSingleton<IWebSocketConnection, WebSocketConnection>();
         services.AddSingleton<IMessageSerializer, JsonMessageSerializer>();
@@ -94,9 +80,13 @@ public static class WebSocketTransportExtensions
         services.AddSingleton<IMessageChannelManager>(provider =>
         {
             var logger = provider.GetRequiredService<ILogger<MessageChannelManager>>();
-            var config = new WebSocketConfig();
-            configure(config);
-            return new MessageChannelManager(logger, config.QueueCapacity, config.QueueCapacity, 100);
+            var config = provider.GetRequiredService<IOptions<WebSocketConfig>>().Value;
+            
+            return new MessageChannelManager(
+                logger, 
+                config.QueueCapacity, 
+                config.QueueCapacity, 
+                100);
         });
 
         // 注册 WebSocket 传输
@@ -106,16 +96,29 @@ public static class WebSocketTransportExtensions
             var connection = provider.GetRequiredService<IWebSocketConnection>();
             var serializer = provider.GetRequiredService<IMessageSerializer>();
             var middlewares = provider.GetServices<IMessageMiddleware>();
-            var config = new WebSocketConfig();
-            configure(config);
+            var config = provider.GetRequiredService<IOptions<WebSocketConfig>>().Value;
             var channelManager = provider.GetRequiredService<IMessageChannelManager>();
             
-            return new CoreAgent.WebSocketTransport.Services.WebSocketTransport(logger, connection, serializer, middlewares, config, channelManager);
+            return new CoreAgent.WebSocketTransport.Services.WebSocketTransport(
+                logger, 
+                connection, 
+                serializer, 
+                middlewares, 
+                config, 
+                channelManager);
         });
-        
-        // 注册默认中间件
+    }
+
+    /// <summary>
+    /// 注册默认中间件
+    /// </summary>
+    /// <param name="services">服务集合</param>
+    private static void RegisterDefaultMiddleware(IServiceCollection services)
+    {
+        // 注册日志中间件
         services.AddWebSocketMiddleware<LoggingMiddleware>();
-        // services.AddWebSocketMiddleware<CacheMiddleware>();
+
+        // 注册缓存中间件（可选）
         services.AddScoped<IMessageMiddleware>(provider =>
         {
             var cache = provider.GetRequiredService<IMemoryCache>();
@@ -123,20 +126,5 @@ public static class WebSocketTransportExtensions
             var config = provider.GetRequiredService<IOptions<WebSocketConfig>>().Value;
             return new CacheMiddleware(cache, logger, config);
         });
-
-        return services;
-    }
-
-    /// <summary>
-    /// 添加 WebSocket 中间件
-    /// </summary>
-    /// <typeparam name="T">中间件类型</typeparam>
-    /// <param name="services">服务集合</param>
-    /// <returns>服务集合</returns>
-    public static IServiceCollection AddWebSocketMiddleware<T>(this IServiceCollection services)
-        where T : class, IMessageMiddleware
-    {
-        services.AddScoped<IMessageMiddleware, T>();
-        return services;
     }
 } 

CoreAgent.WebSocketTransport/Models/WebSocketConfig.cs

@@ -43,7 +43,7 @@ public class WebSocketConfig
     /// 队列容量
     /// </summary>
     [Range(10, 100000, ErrorMessage = "队列容量必须在 10-100000 之间")]
-    public int QueueCapacity { get; set; } = 1000;
+    public int QueueCapacity { get; set; } = 10000;
 
     /// <summary>
     /// 缓存消息 TTL（分钟）

CoreAgent.WebSocketTransport/modify.md

@@ -701,4 +701,87 @@ private async Task ConnectInternalAsync(CancellationToken cancellationToken)
 
 ### 总结
 
-此次修复解决了 WebSocket 连接管理中的严重 Bug，确保了连接在收到 Close 消息后能够正确重连。修复涉及多个层面的改进，包括连接状态管理、任务管理、错误处理等，大大提高了系统的稳定性和可靠性。 
+此次修复解决了 WebSocket 连接管理中的严重 Bug，确保了连接在收到 Close 消息后能够正确重连。修复涉及多个层面的改进，包括连接状态管理、任务管理、错误处理等，大大提高了系统的稳定性和可靠性。 
+
+## 2024年修改记录
+
+### WebSocketTransportExtensions 清理优化
+
+**修改时间**: 2024年
+**修改文件**: 
+- `CoreAgent.WebSocketTransport/Extensions/WebSocketTransportExtensions.cs`
+
+**优化内容**:
+
+1. **代码重构**
+   - 消除重复代码，将公共逻辑提取到私有方法中
+   - 添加参数验证，确保输入参数不为空
+   - 改进代码结构和可读性
+
+2. **方法拆分**
+   - `RegisterCoreServices()` - 注册核心服务组件
+   - `RegisterDefaultMiddleware()` - 注册默认中间件
+   - 提高代码的可维护性和可测试性
+
+3. **错误处理改进**
+   - 添加 `ArgumentNullException` 检查
+   - 确保配置对象正确获取
+   - 改进依赖注入的健壮性
+
+4. **配置管理优化**
+   - 统一使用 `IOptions<WebSocketConfig>` 获取配置
+   - 消除配置获取的重复代码
+   - 确保配置一致性
+
+5. **移除冗余方法**
+   - 移除委托配置重载方法 `AddWebSocketTransport(Action<WebSocketConfig>)`
+   - 简化 API 设计，减少维护成本
+   - 统一使用基于 `IConfiguration` 的配置方式
+
+### Startup 集成实现
+
+**修改时间**: 2024年
+**修改文件**: 
+- `CoreAgent.API/Startup.cs`
+- `CoreAgent.API/Configurations/websocket.json`
+- `CoreAgent.API/Configurations/websocket.Development.json`
+
+**集成内容**:
+
+1. **Startup.cs 修改**
+   - 添加 `using CoreAgent.WebSocketTransport.Extensions;`
+   - 在 `ConfigureServices` 中注册 WebSocket 传输服务
+   - 在配置加载中添加 WebSocket 配置文件
+
+2. **配置文件创建**
+   - `websocket.json` - 生产环境配置
+   - `websocket.Development.json` - 开发环境配置
+   - 包含所有 WebSocketConfig 类的属性配置项
+
+3. **配置项说明**
+   - `Url`: WebSocket 服务器地址
+   - `TimeoutMs`: 连接超时时间（毫秒）
+   - `BatchTimeoutMs`: 批量发送时间窗口（毫秒）
+   - `MaxBatchSize`: 最大批量大小（条消息）
+   - `MaxReconnectAttempts`: 最大重连尝试次数
+   - `QueueCapacity`: 消息队列容量
+   - `CacheTtlMinutes`: 缓存消息 TTL（分钟）
+
+4. **环境差异配置**
+   - 开发环境：较小的队列容量和批量大小，较短的超时时间，较少的重连次数
+   - 生产环境：较大的队列容量和批量大小，较长的超时时间，较多的重连次数
+
+**设计优势**:
+- 代码结构清晰，易于维护
+- 配置灵活，支持不同环境
+- 错误处理完善，提高系统健壮性
+- 遵循依赖注入最佳实践
+- 支持热重载配置
+- API 设计简洁，减少冗余方法
+- 配置文件与模型类完全匹配，确保配置绑定正确
+
+**影响范围**: 
+- WebSocket 传输服务注册
+- 配置管理
+- 中间件集成
+- 应用程序启动流程 

modify.md

@@ -0,0 +1,66 @@
+# 修改记录
+
+## 2024年修改记录
+
+### CellularNetworkService.StartNetworkAsync 方法添加协议客户端配置创建
+
+**修改时间**: 2024年
+**修改文件**: 
+- `CoreAgent.Infrastructure/Services/Network/CellularNetworkService.cs`
+
+**修改内容**:
+
+1. **添加第5.5步协议客户端配置创建**
+   - 在 `StartNetworkAsync` 方法的第5步（更新IP端点管理器）之后添加第5.5步
+   - 直接创建 `ProtocolClientConfigFactory` 实例
+   - 调用 `CreateFromEntities()` 方法创建协议客户端配置
+   - 添加配置创建成功/失败的日志记录
+   - **错误处理**：配置创建失败时立即返回失败结果，不继续执行后续步骤
+   - **优化执行顺序**：将协议客户端配置创建提前到网络启动之前，确保数据可用性和错误隔离
+
+2. **修复Logger类型问题**
+   - 添加 `ILoggerFactory` 依赖注入到构造函数
+   - 使用 `_loggerFactory.CreateLogger<ProtocolClientConfigFactory>()` 创建正确类型的Logger
+   - 确保 `ProtocolClientConfigFactory` 获得正确的Logger实例
+
+3. **具体实现**:
+   ```csharp
+   // 5.5. 创建协议客户端配置
+   var protocolConfigFactory = new ProtocolClientConfigFactory(_loggerFactory.CreateLogger<ProtocolClientConfigFactory>(), _context);
+   var configCreated = protocolConfigFactory.CreateFromEntities();
+   if (configCreated)
+   {
+       _logger.LogInformation("协议客户端配置创建成功，共创建 {ConfigCount} 个配置", protocolConfigFactory.ConfigCount);
+   }
+   else
+   {
+       _logger.LogWarning("协议客户端配置创建失败");
+       return CellularNetworkOperationResult.Failure("协议客户端配置创建失败");
+   }
+   ```
+
+4. **添加必要的依赖注入**
+   - 添加 `ILoggerFactory loggerFactory` 参数到构造函数
+   - 添加 `using CoreAgent.Infrastructure.Services.Network;` 以支持 `ProtocolClientConfigFactory`
+
+5. **设计优势**:
+   - 在IP端点信息准备完成后立即创建协议客户端配置
+   - 不依赖网络启动结果，确保配置创建的独立性
+   - 不依赖依赖注入，直接实例化使用
+   - 提供详细的日志记录便于调试
+   - 保持代码的简洁性和可维护性
+   - 正确处理Logger类型，避免类型不匹配问题
+   - 优化执行顺序，提高错误隔离能力
+   - 完善的错误处理机制，确保配置创建失败时及时停止
+
+**影响范围**: 
+- 蜂窝网络启动流程
+- 协议客户端配置管理
+- 网络状态监控
+- 依赖注入配置（需要更新服务注册）
+
+### LogLayerHelp类名规范化
+
+**修改时间**: 2024年
+**修改文件**: 
+- `