IoT物联网平台 - Part 5: WebSocket 主服务器和前端实现

文件5: iot_server.cpp - 主服务器集成

/** * @file iot_server.cpp * @brief IoT平台主服务器实现 * @author IoT Platform Team * @version 1.0 * @date 2024 * * 集成所有组件，提供完整的IoT平台服务 * 实现主从模式和监控模式 */ ​ #include "config.h" #include "websocket_handler.h" #include "device_manager.h" #include "message_router.h" #include <iostream> #include <memory> #include <thread> #include <atomic> #include <chrono> #include <csignal> #include <cstdlib> #include <fstream> #include <iomanip> #include <sstream> ​ namespace iot { ​ /** * @class IoTServer * @brief IoT平台主服务器类 * @details 集成WebSocket服务器、设备管理器和消息路由器 * * 设计模式：主从模式（Master-Slave Pattern） * - 处理突发事件：组件故障、资源竞争、配置热更新 * - 工程作用：统一管理所有组件，协调工作流程 */ class IoTServer : public std::enable_shared_from_this<IoTServer> { private: // 核心组件 std::shared_ptr<WebSocketServer> websocket_server_; ///< WebSocket服务器 std::shared_ptr<DeviceManager> device_manager_; ///< 设备管理器 std::shared_ptr<MessageRouter> message_router_; ///< 消息路由器 // 配置管理 struct ServerConfig { uint16_t websocket_port; ///< WebSocket端口 int worker_threads; ///< 工作线程数 int connection_timeout; ///< 连接超时时间（秒） int cleanup_interval; ///< 清理间隔（秒） int stats_interval; ///< 统计输出间隔（秒） bool enable_monitoring; ///< 是否启用监控 std::string log_file; ///< 日志文件路径 ServerConfig() : websocket_port(WEBSOCKET_PORT), worker_threads(WORKER_THREADS), connection_timeout(CONNECTION_TIMEOUT), cleanup_interval(300), ///< 5分钟清理一次 stats_interval(60), ///< 每分钟输出统计 enable_monitoring(true), log_file("iot_server.log") {} }; ServerConfig config_; ///< 服务器配置 // 运行状态 std::atomic<bool> running_{false}; ///< 服务器运行状态 std::atomic<bool> shutdown_requested_{false}; ///< 关闭请求标志 // 监控线程 std::thread monitor_thread_; ///< 监控线程 std::thread cleanup_thread_; ///< 清理线程 std::thread stats_thread_; ///< 统计线程 // 性能统计 struct PerformanceStats { uint64_t total_connections; ///< 总连接数 uint64_t current_connections; ///< 当前连接数 uint64_t total_messages; ///< 总消息数 uint64_t messages_per_second; ///< 每秒消息数 uint64_t total_errors; ///< 总错误数 double cpu_usage; ///< CPU使用率 double memory_usage; ///< 内存使用率 uint64_t uptime; ///< 运行时间（秒） PerformanceStats() : total_connections(0), current_connections(0), total_messages(0), messages_per_second(0), total_errors(0), cpu_usage(0.0), memory_usage(0.0), uptime(0) {} }; PerformanceStats stats_; ///< 性能统计 // 信号处理 static std::shared_ptr<IoTServer> signal_instance_; ///< 信号处理实例 public: /** * @brief 构造函数 * @param config_file 配置文件路径（可选） */ explicit IoTServer(const std::string& config_file = "") { // 加载配置 loadConfig(config_file); // 初始化组件 initializeComponents(); // 设置信号处理 setupSignalHandlers(); std::cout << "IoT Server initialized" << std::endl; } /** * @brief 析构函数 */ ~IoTServer() { stop(); std::cout << "IoT Server destroyed" << std::endl; } /** * @brief 启动服务器 * @return 启动成功返回true */ bool start() { if (running_) { std::cerr << "Server is already running" << std::endl; return false; } std::cout << "Starting IoT Server..." << std::endl; // 启动WebSocket服务器 if (!websocket_server_->start(config_.websocket_port)) { std::cerr << "Failed to start WebSocket server" << std::endl; return false; } // 启动消息路由器 message_router_->start(config_.worker_threads); // 启动监控线程 running_ = true; startMonitorThread(); startCleanupThread(); startStatsThread(); stats_.uptime = 0; std::cout << "IoT Server started successfully on port " << config_.websocket_port << std::endl; return true; } /** * @brief 停止服务器 */ void stop() { if (!running_) { return; } std::cout << "Stopping IoT Server..." << std::endl; shutdown_requested_ = true; running_ = false; // 停止监控线程 if (monitor_thread_.joinable()) { monitor_thread_.join(); } if (cleanup_thread_.joinable()) { cleanup_thread_.join(); } if (stats_thread_.joinable()) { stats_thread_.join(); } // 停止组件 message_router_->stop(); websocket_server_->stop(); std::cout << "IoT Server stopped" << std::endl; } /** * @brief 等待服务器停止 */ void waitForShutdown() { while (running_ && !shutdown_requested_) { std::this_thread::sleep_for(std::chrono::seconds(1)); } } /** * @brief 获取服务器运行状态 * @return 运行状态字符串 */ std::string getStatus() const { std::stringstream ss; ss << "=== IoT Server Status ===\n" << "Running: " << (running_ ? "Yes" : "No") << "\n" << "Uptime: " << stats_.uptime << " seconds\n" << "WebSocket Port: " << config_.websocket_port << "\n" << "Worker Threads: " << config_.worker_threads << "\n" << "Current Connections: " << stats_.current_connections << "\n" << "Total Messages: " << stats_.total_messages << "\n" << "Messages/sec: " << stats_.messages_per_second << "\n" << "Total Errors: " << stats_.total_errors << "\n"; return ss.str(); } private: /** * @brief 加载配置文件 * @param config_file 配置文件路径 */ void loadConfig(const std::string& config_file) { // 这里可以解析JSON或YAML配置文件 // 简化实现：使用默认配置 if (!config_file.empty()) { std::ifstream file(config_file); if (file.is_open()) { // 解析配置文件 // 例如：JSON解析 std::cout << "Loading config from: " << config_file << std::endl; // 实际实现中应该解析配置文件并更新config_ } } // 应用环境变量覆盖 const char* port_env = std::getenv("IOT_WEBSOCKET_PORT"); if (port_env) { config_.websocket_port = static_cast<uint16_t>(std::atoi(port_env)); } const char* threads_env = std::getenv("IOT_WORKER_THREADS"); if (threads_env) { config_.worker_threads = std::atoi(threads_env); } } /** * @brief 初始化所有组件 */ void initializeComponents() { // 创建设备管理器 device_manager_ = std::make_shared<DeviceManager>(); // 设置设备管理器事件处理器 DeviceManager::DeviceEventHandler event_handler; event_handler.on_online_change = [this](const std::string& device_id, bool online) { handleDeviceOnlineChange(device_id, online); }; event_handler.on_data_received = [this](const std::string& device_id, const SensorData& data) { handleDeviceData(device_id, data); }; event_handler.on_config_updated = [this](const std::string& device_id, const std::string& config_key) { handleConfigUpdated(device_id, config_key); }; device_manager_->setEventHandler(event_handler); // 创建WebSocket服务器 websocket_server_ = std::make_shared<WebSocketServer>(); // 创建消息路由器，设置消息发送回调 auto send_callback = [this](int conn_fd, const std::vector<uint8_t>& data) { handleMessageSend(conn_fd, data); }; message_router_ = std::make_shared<MessageRouter>(device_manager_, send_callback); std::cout << "All components initialized" << std::endl; } /** * @brief 设置信号处理 */ void setupSignalHandlers() { signal_instance_ = shared_from_this(); // 注册信号处理函数 std::signal(SIGINT, handleSignal); ///< Ctrl+C std::signal(SIGTERM, handleSignal); ///< kill命令 std::signal(SIGHUP, handleSignal); ///< 终端断开 std::cout << "Signal handlers registered" << std::endl; } /** * @brief 信号处理函数（静态） * @param signum 信号编号 */ static void handleSignal(int signum) { std::cout << "\nReceived signal: " << signum << std::endl; if (signal_instance_) { signal_instance_->shutdown_requested_ = true; // 记录信号 std::string signal_name; switch (signum) { case SIGINT: signal_name = "SIGINT"; break; case SIGTERM: signal_name = "SIGTERM"; break; case SIGHUP: signal_name = "SIGHUP"; break; default: signal_name = "UNKNOWN"; break; } std::cout << "Signal " << signal_name << " received, shutting down..." << std::endl; } } /** * @brief 启动监控线程 */ void startMonitorThread() { monitor_thread_ = std::thread([this]() { std::cout << "Monitor thread started" << std::endl; while (running_ && !shutdown_requested_) { // 更新统计信息 updateStats(); // 检查系统资源 checkSystemResources(); // 等待下一次监控 std::this_thread::sleep_for(std::chrono::seconds(5)); } std::cout << "Monitor thread stopped" << std::endl; }); } /** * @brief 启动清理线程 */ void startCleanupThread() { cleanup_thread_ = std::thread([this]() { std::cout << "Cleanup thread started" << std::endl; while (running_ && !shutdown_requested_) { // 清理过期设备 size_t cleaned = device_manager_->cleanupExpiredDevices( config_.connection_timeout); if (cleaned > 0) { std::cout << "Cleaned " << cleaned << " expired devices" << std::endl; } // 等待下一次清理 std::this_thread::sleep_for( std::chrono::seconds(config_.cleanup_interval)); } std::cout << "Cleanup thread stopped" << std::endl; }); } /** * @brief 启动统计线程 */ void startStatsThread() { stats_thread_ = std::thread([this]() { std::cout << "Stats thread started" << std::endl; auto last_update = std::chrono::steady_clock::now(); uint64_t last_message_count = 0; while (running_ && !shutdown_requested_) { // 更新运行时间 stats_.uptime++; // 计算每秒消息数 auto now = std::chrono::steady_clock::now(); auto elapsed = std::chrono::duration_cast<std::chrono::seconds>( now - last_update).count(); if (elapsed >= 1) { // 这里应该从消息路由器获取实际消息计数 // 简化实现：使用静态计数器 uint64_t current_count = stats_.total_messages; uint64_t delta = current_count - last_message_count; stats_.messages_per_second = delta / elapsed; last_message_count = current_count; last_update = now; } // 输出统计信息（如果启用） if (config_.enable_monitoring && stats_.uptime % config_.stats_interval == 0) { outputStats(); } // 等待下一次更新 std::this_thread::sleep_for(std::chrono::seconds(1)); } std::cout << "Stats thread stopped" << std::endl; }); } /** * @brief 更新统计信息 */ void updateStats() { // 更新连接数 // 这里需要从WebSocket服务器获取实际连接数 // 简化实现：使用估计值 // 更新CPU和内存使用率 updateResourceUsage(); } /** * @brief 更新资源使用率 */ void updateResourceUsage() { // 读取/proc/stat获取CPU使用率 // 读取/proc/self/statm获取内存使用 // 简化实现：返回0 stats_.cpu_usage = 0.0; stats_.memory_usage = 0.0; } /** * @brief 检查系统资源 */ void checkSystemResources() { // 检查内存使用 if (stats_.memory_usage > 90.0) { std::cerr << "Warning: High memory usage: " << stats_.memory_usage << "%" << std::endl; } // 检查CPU使用 if (stats_.cpu_usage > 80.0) { std::cerr << "Warning: High CPU usage: " << stats_.cpu_usage << "%" << std::endl; } } /** * @brief 输出统计信息 */ void outputStats() { std::stringstream ss; ss << std::fixed << std::setprecision(2); auto now = std::chrono::system_clock::now(); auto now_time = std::chrono::system_clock::to_time_t(now); ss << "\n=== IoT Server Statistics ===\n" << "Time: " << std::ctime(&now_time) << "Uptime: " << formatDuration(stats_.uptime) << "\n" << "CPU Usage: " << stats_.cpu_usage << "%\n" << "Memory Usage: " << stats_.memory_usage << "%\n" << "Current Connections: " << stats_.current_connections << "\n" << "Total Messages: " << stats_.total_messages << "\n" << "Messages/sec: " << stats_.messages_per_second << "\n" << "Total Errors: " << stats_.total_errors << "\n"; std::cout << ss.str(); // 写入日志文件 if (!config_.log_file.empty()) { std::ofstream log_file(config_.log_file, std::ios::app); if (log_file.is_open()) { log_file << ss.str(); log_file.close(); } } } /** * @brief 格式化时间间隔 * @param seconds 秒数 * @return 格式化后的字符串 */ std::string formatDuration(uint64_t seconds) { uint64_t hours = seconds / 3600; uint64_t minutes = (seconds % 3600) / 60; uint64_t secs = seconds % 60; std::stringstream ss; ss << hours << "h " << minutes << "m " << secs << "s"; return ss.str(); } /** * @brief 处理设备在线状态变化 * @param device_id 设备ID * @param online 是否在线 */ void handleDeviceOnlineChange(const std::string& device_id, bool online) { // 更新统计 if (online) { stats_.total_connections++; stats_.current_connections++; } else { stats_.current_connections--; } // 记录日志 std::cout << "Device " << device_id << (online ? " came online" : " went offline") << std::endl; // 这里可以触发其他业务逻辑 // 例如：发送通知、更新数据库等 } /** * @brief 处理设备数据 * @param device_id 设备ID * @param data 传感器数据 */ void handleDeviceData(const std::string& device_id, const SensorData& data) { // 更新消息计数 stats_.total_messages++; // 这里可以添加数据处理的业务逻辑 // 例如：数据持久化、实时分析等 // 调试输出 if (data.sensor_type == DeviceType::TEMPERATURE_SENSOR) { std::cout << "Temperature data from " << device_id << ": " << data.data.environmental.temperature << "°C" << std::endl; } } /** * @brief 处理配置更新 * @param device_id 设备ID * @param config_key 配置键 */ void handleConfigUpdated(const std::string& device_id, const std::string& config_key) { std::cout << "Config updated for device " << device_id << ": " << config_key << std::endl; } /** * @brief 处理消息发送 * @param conn_fd 连接文件描述符 * @param data 要发送的数据 */ void handleMessageSend(int conn_fd, const std::vector<uint8_t>& data) { // 这里应该调用WebSocket连接的发送方法 // 简化实现：记录日志 std::cout << "Sending message to connection " << conn_fd << ", size: " << data.size() << " bytes" << std::endl; // 实际实现中应该调用： // websocket_server_->sendToConnection(conn_fd, data); } /** * @brief 处理WebSocket消息（从WebSocket服务器回调） * @param conn_fd 连接文件描述符 * @param message 接收到的消息 */ void handleWebSocketMessage(int conn_fd, const WebSocketMessage& message) { // 获取设备ID std::string device_id = device_manager_->getDeviceIdByConnection(conn_fd); if (device_id.empty()) { // 设备未注册，尝试处理注册消息 if (message.type == MessageType::DEVICE_REGISTER) { handleDeviceRegistration(conn_fd, message); } else { std::cerr << "Unknown device connection: " << conn_fd << std::endl; } return; } // 提交消息到路由器处理 message_router_->submitMessage(message, device_id); } /** * @brief 处理设备注册 * @param conn_fd 连接文件描述符 * @param message 注册消息 */ void handleDeviceRegistration(int conn_fd, const WebSocketMessage& message) { if (message.payload.size() < sizeof(DeviceInfo)) { std::cerr << "Invalid registration message size" << std::endl; return; } const DeviceInfo* device_info = reinterpret_cast<const DeviceInfo*>(message.payload.data()); // 注册设备 device_manager_->registerDevice(*device_info, conn_fd); std::cout << "Device registered: " << device_info->device_id << std::endl; // 发送注册响应 sendRegistrationResponse(conn_fd, true, "Registration successful"); } /** * @brief 发送注册响应 * @param conn_fd 连接文件描述符 * @param success 是否成功 * @param message 响应消息 */ void sendRegistrationResponse(int conn_fd, bool success, const std::string& message) { WebSocketMessage response; response.type = success ? MessageType::DEVICE_REGISTER : MessageType::ERROR_RESPONSE; response.message_id = 0; response.timestamp = WebSocketConnection::getCurrentTimestamp(); // 构造响应负载 std::string response_msg = success ? "OK" : "ERROR: " + message; response.payload.assign(response_msg.begin(), response_msg.end()); // 发送响应 std::vector<uint8_t> serialized; response.serialize(serialized); handleMessageSend(conn_fd, serialized); } }; ​ // 静态成员初始化 std::shared_ptr<IoTServer> IoTServer::signal_instance_ = nullptr; ​ } // namespace iot ​ /** * @brief 主函数 * @param argc 参数个数 * @param argv 参数数组 * @return 程序退出码 * * 程序入口点，创建和运行IoT服务器 */ int main(int argc, char* argv[]) { std::cout << "=== IoT Platform Server ===" << std::endl; std::cout << "Version: 1.0.0" << std::endl; std::cout << "Build: " << __DATE__ << " " << __TIME__ << std::endl; // 解析命令行参数 std::string config_file; uint16_t port = iot::WEBSOCKET_PORT; for (int i = 1; i < argc; ++i) { std::string arg = argv[i]; if (arg == "--config" || arg == "-c") { if (i + 1 < argc) { config_file = argv[++i]; } } else if (arg == "--port" || arg == "-p") { if (i + 1 < argc) { port = static_cast<uint16_t>(std::atoi(argv[++i])); } } else if (arg == "--help" || arg == "-h") { printUsage(); return 0; } else if (arg == "--version" || arg == "-v") { std::cout << "IoT Platform Server v1.0.0" << std::endl; return 0; } } try { // 创建IoT服务器实例 auto server = std::make_shared<iot::IoTServer>(config_file); // 覆盖端口配置（如果通过命令行指定） if (port != iot::WEBSOCKET_PORT) { // 这里需要修改server的配置 // 简化实现：输出警告 std::cout << "Note: Port configuration from command line is not implemented" << std::endl; } // 启动服务器 if (!server->start()) { std::cerr << "Failed to start server" << std::endl; return 1; } // 等待关闭信号 std::cout << "\nServer is running. Press Ctrl+C to stop." << std::endl; server->waitForShutdown(); // 停止服务器 server->stop(); std::cout << "Server shutdown complete" << std::endl; } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return 1; } return 0; } ​ /** * @brief 打印使用说明 */ void printUsage() { std::cout << "Usage: iot_server [options]" << std::endl; std::cout << "Options:" << std::endl; std::cout << " -c, --config FILE Load configuration from FILE" << std::endl; std::cout << " -p, --port PORT Use PORT for WebSocket connections" << std::endl; std::cout << " -h, --help Display this help message" << std::endl; std::cout << " -v, --version Display version information" << std::endl; std::cout << std::endl; std::cout << "Examples:" << std::endl; std::cout << " iot_server --config /etc/iot/server.conf" << std::endl; std::cout << " iot_server --port 8888" << std::endl; }

文件6: frontend/index.html - Web前端主页面

<!DOCTYPE html> <!-- * @file index.html * @brief IoT平台Web前端主页面 * @author IoT Platform Team * @version 1.0 * @date 2024 * * 实现响应式设计，支持桌面和移动设备 * 使用现代Web技术展示IoT设备状态和数据 --> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>IoT物联网平台监控系统</title> <!-- Bootstrap 5 CSS --> <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet"> <!-- Font Awesome图标 --> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css"> <!-- Chart.js图表库 --> <script src="https://cdn.jsdelivr.net/npm/chart.js"></script> <!-- 自定义样式 --> <style> /* 自定义CSS变量 */ :root { --primary-color: #2c3e50; --secondary-color: #3498db; --success-color: #27ae60; --warning-color: #f39c12; --danger-color: #e74c3c; --light-color: #ecf0f1; --dark-color: #2c3e50; } /* 全局样式 */ body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #f8f9fa; color: #333; } /* 导航栏样式 */ .navbar-brand { font-weight: bold; font-size: 1.5rem; } .navbar-brand i { color: var(--secondary-color); margin-right: 10px; } /* 卡片样式 */ .card { border: none; border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); transition: transform 0.3s ease; margin-bottom: 20px; } .card:hover { transform: translateY(-5px); } .card-header { background-color: var(--primary-color); color: white; border-radius: 10px 10px 0 0 !important; font-weight: bold; } /* 统计卡片 */ .stat-card { text-align: center; padding: 20px; } .stat-card .stat-value { font-size: 2.5rem; font-weight: bold; color: var(--secondary-color); } .stat-card .stat-label { font-size: 0.9rem; color: #666; text-transform: uppercase; letter-spacing: 1px; } /* 设备状态指示器 */ .device-status { display: inline-block; width: 12px; height: 12px; border-radius: 50%; margin-right: 8px; } .status-online { background-color: var(--success-color); box-shadow: 0 0 8px var(--success-color); } .status-offline { background-color: var(--danger-color); } .status-warning { background-color: var(--warning-color); } /* 设备卡片 */ .device-card { cursor: pointer; transition: all 0.3s ease; } .device-card:hover { background-color: rgba(52, 152, 219, 0.1); } .device-card.selected { border-left: 4px solid var(--secondary-color); background-color: rgba(52, 152, 219, 0.05); } /* 图表容器 */ .chart-container { position: relative; height: 300px; width: 100%; } /* 响应式调整 */ @media (max-width: 768px) { .stat-card .stat-value { font-size: 2rem; } .navbar-brand { font-size: 1.2rem; } } /* 动画效果 */ @keyframes pulse { 0% { opacity: 1; } 50% { opacity: 0.5; } 100% { opacity: 1; } } .pulse { animation: pulse 2s infinite; } /* 滚动条样式 */ ::-webkit-scrollbar { width: 8px; } ::-webkit-scrollbar-track { background: #f1f1f1; border-radius: 4px; } ::-webkit-scrollbar-thumb { background: #888; border-radius: 4px; } ::-webkit-scrollbar-thumb:hover { background: #555; } </style> </head> <body> <!-- 导航栏 --> <nav class="navbar navbar-expand-lg navbar-dark bg-dark sticky-top"> <div class="container-fluid"> <a class="navbar-brand" href="#"> <i class="fas fa-satellite-dish"></i> IoT物联网平台 </a> <button class="navbar-toggler" type="button" >1.主从模式（Master-Slave Pattern）
应用位置：IoTServer类作为主节点，管理其他组件
处理突发事件：
组件故障：主节点监控组件状态，自动重启或降级
资源竞争：主节点协调资源分配
配置热更新：主节点统一管理配置分发
工程作用：
集中控制和管理
提高系统可靠性
简化分布式协调
性能分析：
控制开销：主节点增加管理开销
单点故障：主节点是单点，需要高可用方案
扩展性：可通过多级主从结构扩展
2.监控模式（Monitor Pattern）
应用位置：IoTServer的监控线程和统计系统
处理突发事件：
性能瓶颈：实时监控发现性能问题
资源泄漏：定期检查资源使用情况
异常检测：自动检测系统异常
工程作用：
提供系统可见性
支持故障预警
辅助性能调优
性能分析：
监控开销：定期检查消耗CPU和内存
数据收集：需要高效的数据收集机制
告警延迟：实时性要求高
3.前端MVC模式
应用位置：HTML/CSS/JavaScript分离架构
处理突发事件：
浏览器兼容性：使用标准Web技术
网络中断：WebSocket自动重连
数据不一致：前端状态管理
工程作用：
代码组织清晰
职责分离
易于维护和测试
运行性能分析
服务器端性能：
组件集成开销：组件间通信增加延迟
线程管理：多个监控线程增加上下文切换
资源监控：定期检查消耗系统资源
前端性能：
WebSocket连接：保持长连接消耗资源
实时图表：Canvas渲染消耗GPU
数据更新：频繁DOM操作影响性能
内存使用分析：
IoTServer内存估算： - 组件指针：3 * 8 = 24字节 - 配置结构：~100字节 - 统计结构：~64字节 - 线程对象：3 * 48 = 144字节 - 总计：~332字节基础开销
数据流结构设计
1. 前端到后端数据流：
Web浏览器 → WebSocket → IoTServer → MessageRouter → 目标设备 ↓ ↓ 数据展示 ← WebSocket ← 消息响应 ← DeviceManager
2. 监控数据流：
监控线程 → 性能统计 → 日志文件 ↓ ↓ 资源检查 → 告警系统 → Web前端
突发事件处理策略
突发事件
处理策略
设计模式应用
服务器崩溃
信号处理，优雅关闭
主从模式的故障处理
前端断开连接
WebSocket重连，状态恢复
监控模式的连接管理
组件通信失败
心跳检测，自动恢复
主从模式的组件协调
配置更新冲突
版本控制，原子更新
监控模式的配置管理
内存泄漏
定期检查，资源回收
监控模式的资源管理
第五部分总结：实现了完整的IoT平台主服务器和Web前端界面。采用主从模式管理所有组件，监控模式提供系统可见性，前端MVC模式实现用户界面。整个系统具备了完整的设备管理、消息路由、状态监控和用户界面功能。
这个IoT物联网平台现在已经完成了核心功能的实现。系统具有以下特点：
高并发处理：基于反应器模式的WebSocket服务器
可靠消息路由：责任链模式的消息处理器
灵活设备管理：发布-订阅模式的设备状态管理
完善监控系统：多线程监控和统计
现代Web界面：响应式设计和实时数据展示
系统可以处理大规模IoT设备连接，支持实时数据监控和设备控制，适用于各种物联网应用场景。