为什么要使用WebSocket：实时通信技术深度解析

最新推荐文章于 2025-11-30 22:51:53 发布

原创最新推荐文章于 2025-11-30 22:51:53 发布 · 953 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#websocket #网络协议 #网络 #前端

为什么要使用WebSocket：实时通信技术深度解析

引言

在现代Web应用中，实时通信已成为不可或缺的功能需求。从在线聊天、股票交易、在线游戏到协同编辑，实时数据交互对用户体验至关重要。本文将深入分析四种主要的实时通信技术：WebSocket、SSE（Server-Sent Events）、轮询（Polling）和Socket，并通过对比阐述WebSocket技术的优势和必要性。

四种实时通信技术详解

1. WebSocket

基本概念

WebSocket是一种在单个TCP连接上进行全双工通信的协议，由HTML5规范引入。它允许服务器和客户端之间建立持久连接，实现真正的双向实时通信。

工作原理

握手阶段：客户端通过HTTP Upgrade请求建立WebSocket连接
协议升级：服务器响应101状态码，协议从HTTP升级为WebSocket
持久连接：建立TCP连接后，双方可以随时发送数据帧
数据帧传输：使用轻量级的帧格式传输数据，减少协议开销

优点

真正的双向通信：服务器可以主动推送数据到客户端
低延迟：连接建立后无需HTTP头部开销
高效传输：数据帧格式轻量，协议开销小
持久连接：避免频繁的连接建立和断开
跨域支持：支持跨域通信

缺点

协议复杂性：需要处理连接状态管理
浏览器兼容性：较老的浏览器不支持
服务器资源：需要维护大量持久连接
防火墙/代理：可能被某些网络设备阻断

适用场景

实时聊天应用
在线游戏
股票交易平台
协同编辑工具
实时数据监控

2. SSE（Server-Sent Events）

基本概念

SSE是HTML5规范的一部分，允许服务器向客户端推送事件流。它是一种单向通信机制，仅支持服务器到客户端的单向数据推送。

工作原理

建立连接：客户端通过EventSource API建立连接
事件流传输：服务器发送text/event-stream格式的数据
事件处理：客户端监听特定事件类型进行处理
自动重连：连接断开时自动尝试重新连接

优点

简单易用：API简单，易于实现
自动重连：内置重连机制
文本格式：数据格式简单易读
HTTP兼容：基于HTTP，兼容性好

缺点

单向通信：只能服务器向客户端推送
文本限制：仅支持文本数据传输
连接限制：浏览器对并发连接数有限制

适用场景

新闻推送
股票价格更新
社交媒体通知
实时日志监控

3. 轮询（Polling）

基本概念

轮询是最简单的实时通信实现方式，客户端定期向服务器发送请求检查是否有新数据。

工作原理

定期请求：客户端按固定间隔发送HTTP请求
服务器响应：服务器返回当前数据状态
重复过程：无论是否有数据更新都重复此过程

类型

短轮询：固定时间间隔请求
长轮询：服务器保持请求直到有数据或超时

优点

实现简单：技术门槛低
兼容性好：所有浏览器都支持
防火墙友好：基于标准HTTP

缺点

高延迟：数据更新不及时
资源浪费：大量无效请求
服务器压力：频繁请求增加服务器负载
实时性差：无法实现真正的实时通信

适用场景

简单的数据更新
对实时性要求不高的场景
兼容性要求极高的环境

4. Socket（传统Socket编程）

基本概念

传统Socket编程是操作系统级别的网络通信接口，提供底层的双向通信能力。

工作原理

创建Socket：应用程序创建Socket对象
绑定端口：绑定到特定端口
监听连接：服务器监听客户端连接
数据传输：通过Socket发送和接收数据

优点

完全控制：提供最大的灵活性
高性能：直接操作系统接口
协议无关：可以自定义任何协议

缺点

复杂性高：需要处理底层细节
浏览器限制：浏览器环境无法直接使用
安全性：需要自行处理安全机制
跨平台问题：不同平台实现差异

适用场景

桌面应用程序
游戏服务器
高性能后端服务
自定义协议开发

技术对比分析

通信模式对比

技术	通信模式	实时性	协议开销	实现复杂度
WebSocket	全双工双向	极高	低	中等
SSE	单向推送	高	中等	简单
轮询	客户端请求	低	高	简单
Socket	全双工双向	极高	最低	复杂

性能对比

延迟表现

WebSocket：连接建立后延迟最低（毫秒级）
SSE：中等延迟，受HTTP协议限制
轮询：延迟最高，受轮询间隔影响
Socket：延迟最低，但受网络条件影响

资源消耗

WebSocket：连接维护成本中等
SSE：服务器推送成本较低
轮询：请求/响应循环资源浪费严重
Socket：资源消耗最低，但开发成本高

适用场景对比

场景需求	WebSocket	SSE	轮询	Socket
双向实时聊天	✅ 最佳选择	❌ 不支持	❌ 不适用	✅ 可用但复杂
服务器推送通知	✅ 优秀	✅ 最佳选择	⚠️ 可用但低效	✅ 可用
简单数据更新	✅ 过度	✅ 合适	✅ 简单实现	❌ 过度复杂
高性能游戏	✅ 优秀	❌ 不适用	❌ 不适用	✅ 最佳选择
浏览器环境	✅ 原生支持	✅ 原生支持	✅ 完全支持	❌ 不支持

WebSocket的优势与必要性

1. 真正的实时双向通信

WebSocket解决了HTTP协议固有的请求-响应模式的限制，实现了真正的双向实时通信。在需要频繁数据交换的场景中，这种能力至关重要。

2. 显著降低网络开销

相比轮询技术，WebSocket避免了重复的HTTP头部传输，大大减少了网络带宽消耗。对于移动端应用或网络条件较差的环境，这一优势尤为明显。

3. 改善用户体验

低延迟的实时通信能够提供更流畅的用户体验。在聊天应用、在线协作等场景中，用户可以感受到几乎无延迟的交互体验。

4. 服务器性能优化

WebSocket的持久连接机制减少了服务器处理连接建立和断开的开销，使得服务器能够更高效地处理大量并发连接。

5. 现代Web标准支持

作为HTML5标准的一部分，WebSocket得到了现代浏览器的广泛支持，且具有很好的向前兼容性。

实际应用案例

案例1：实时聊天应用

// WebSocket实现实时聊天的核心优势：
// 1. 消息即时到达，无感知延迟
// 2. 支持群聊、私聊等多种聊天模式
// 3. 在线状态实时更新
// 4. 消息已读状态同步

案例2：金融交易平台

// WebSocket在金融交易中的优势：
// 1. 股价实时推送，毫秒级更新
// 2. 交易指令即时执行
// 3. 市场数据实时分析
// 4. 风险控制实时监控

案例3：在线协作工具

// WebSocket支持多人协作：
// 1. 文档实时同步编辑
// 2. 光标位置共享
// 3. 操作历史追踪
// 4. 冲突解决机制

WebSocket Hook实现详解

分步实现方案

下面将WebSocket Hook的实现分解为多个逻辑清晰的步骤，每个步骤包含对应的代码片段、设计思路和技术原理说明。

步骤1：基础接口定义和配置管理

设计思路：首先定义清晰的类型接口和配置选项，为后续实现提供类型安全和配置灵活性。

技术选型理由：

使用TypeScript接口确保类型安全
合理的默认配置减少用户配置负担
模块化设计便于扩展和维护

实现原理：通过接口定义约束数据结构，通过配置合并提供灵活的定制能力。

/**
 * WebSocket配置选项接口
 */
export interface WebSocketOptions {
  url: string;
  protocols?: string | string[];
  heartbeatInterval?: number;
  heartbeatTimeout?: number;
  maxReconnectAttempts?: number;
  reconnectInterval?: number;
  reconnectDelay?: number;
  autoConnect?: boolean;
  connectTimeout?: number;
  timeGradient?: {
    enabled?: boolean;
    windowSize?: number;
    minInterval?: number;
    maxInterval?: number;
    smoothingFactor?: number;
  };
}

/**
 * 默认配置常量
 */
const DEFAULT_OPTIONS: Required<Omit<WebSocketOptions, 'url' | 'protocols'>> = {
  heartbeatInterval: 30000,
  heartbeatTimeout: 10000,
  maxReconnectAttempts: 5,
  reconnectInterval: 3000,
  reconnectDelay: 1000,
  autoConnect: true,
  connectTimeout: 10000,
  timeGradient: {
    enabled: true,
    windowSize: 60000,
    minInterval: 1000,
    maxInterval: 60000,
    smoothingFactor: 0.7,
  },
};

步骤2：消息处理器和Hook接口定义

设计思路：定义消息处理机制和Hook的公共接口，实现类型安全的消息分发。

技术选型理由：

泛型支持多种消息类型
Set数据结构提高处理器查找效率
清晰的接口定义便于使用和扩展

实现原理：使用Map存储消息类型与处理器的映射关系，支持同一消息类型的多个处理器。

/**
 * 消息处理器函数类型定义
 */
export interface MessageHandler<T = any> {
  (data: T): void;
}

/**
 * WebSocket Hook接口定义
 */
export interface WebSocketHook {
  readonly readyState: number;
  readonly isConnected: boolean;
  connect(): void;
  close(code?: number, reason?: string): void;
  send<T = any>(message: T, type?: string): boolean;
  on<T = any>(type: string, handler: MessageHandler<T>): void;
  off(type: string, handler?: MessageHandler): void;
  getStats(): WebSocketStats;
}

步骤3：时间梯度优化算法实现

设计思路：实现自适应时间间隔优化算法，根据网络状况动态调整参数。

技术选型理由：

基于统计学的变异系数评估连接稳定性
平滑因子避免参数剧烈波动
频率限制防止过度计算

实现原理：通过分析历史连接时间间隔的统计特征，计算最优的心跳和重连间隔。

class TimeGradientCalculator {
  private windowSize: number;
  private minInterval: number;
  private maxInterval: number;
  private smoothingFactor: number;
  private timeRecords: number[] = [];
  private latencyRecords: number[] = [];
  private currentInterval: number;

  constructor(config: Required<WebSocketOptions['timeGradient']>) {
    this.windowSize = config.windowSize;
    this.minInterval = config.minInterval;
    this.maxInterval = config.maxInterval;
    this.smoothingFactor = config.smoothingFactor;
    this.currentInterval = config.minInterval;
  }

  addRecord(timestamp: number, latency?: number): void {
    this.timeRecords.push(timestamp);
    if (latency !== undefined) {
      this.latencyRecords.push(latency);
    }
    this.cleanupRecords();
    this.calculateOptimalInterval();
  }

  private calculateOptimalInterval(): void {
    if (this.timeRecords.length < 2) {
      this.currentInterval = this.minInterval;
      return;
    }

    // 计算时间间隔的变异系数
    const intervals: number[] = [];
    for (let i = 1; i < this.timeRecords.length; i++) {
      intervals.push(this.timeRecords[i] - this.timeRecords[i - 1]);
    }

    const mean = intervals.reduce((sum, val) => sum + val, 0) / intervals.length;
    const variance = intervals.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / intervals.length;
    const coefficientOfVariation = Math.sqrt(variance) / mean;

    // 基于变异系数和延迟计算自适应间隔
    let adaptiveInterval = mean;
    if (coefficientOfVariation > 0.5) {
      adaptiveInterval *= 1 + coefficientOfVariation;
    }

    // 应用平滑因子和边界限制
    this.currentInterval = Math.max(
      this.minInterval,
      Math.min(this.maxInterval, adaptiveInterval)
    );
  }

  getCurrentInterval(): number {
    return this.currentInterval;
  }
}

步骤4：连接管理和状态维护

设计思路：实现完整的连接生命周期管理，包括连接建立、断开、重连等状态转换。

技术选型理由：

状态机模式管理连接状态
指数退避算法实现智能重连
超时机制防止连接阻塞

实现原理：通过WebSocket原生事件和定时器实现连接状态的管理和自动恢复。

const connect = (): void => {
  if (ws?.readyState === WebSocketState.CONNECTING) {
    console.warn('WebSocket连接正在进行中，跳过重复连接');
    return;
  }

  if (ws) {
    ws.close();
    ws = null;
  }

  try {
    ws = new WebSocket(config.url, config.protocols);
    isManualClose = false;

    // 设置连接超时
    const connectTimeoutTimer = setTimeout(() => {
      if (ws?.readyState === WebSocketState.CONNECTING) {
        console.error('WebSocket连接超时');
        ws.close();
        handleDisconnect();
      }
    }, config.connectTimeout);

    ws.onopen = (event) => {
      clearTimeout(connectTimeoutTimer);
      console.log('WebSocket连接成功');
      stats.connectCount++;
      reconnectAttempts = 0;
      startHeartbeat();
    };

    ws.onclose = (event) => {
      console.log(`WebSocket连接关闭，代码: ${event.code}, 原因: ${event.reason}`);
      if (!isManualClose) {
        handleDisconnect();
      }
    };

    ws.onerror = (event) => {
      console.error('WebSocket连接错误', event);
    };

  } catch (error) {
    console.error('WebSocket连接创建失败', error);
    handleDisconnect();
  }
};

步骤5：心跳检测和健康监控

设计思路：实现自适应心跳检测机制，动态调整检测频率基于网络状况。

技术选型理由：

双向验证确保连接有效性
动态间隔适应网络变化
超时检测快速发现连接问题

实现原理：定期发送心跳包并等待响应，通过响应时间测量网络延迟，动态调整检测频率。

const sendHeartbeat = (): void => {
  if (!getIsConnected()) return;

  const heartbeatMessage = {
    type: HEARTBEAT_TYPE,
    timestamp: Date.now(),
  };

  if (send(heartbeatMessage)) {
    lastHeartbeatSentTime = Date.now();

    // 设置心跳超时检查
    if (heartbeatTimeoutTimer) {
      clearTimeout(heartbeatTimeoutTimer);
    }

    heartbeatTimeoutTimer = setTimeout(() => {
      console.warn('WebSocket心跳超时，尝试重连');
      handleDisconnect();
    }, config.heartbeatTimeout);
  }
};

const startHeartbeat = (): void => {
  stopHeartbeat();

  const optimalInterval = config.timeGradient.enabled
    ? timeGradient.getCurrentInterval()
    : config.heartbeatInterval;

  heartbeatTimer = setInterval(() => {
    sendHeartbeat();
  }, optimalInterval);

  sendHeartbeat();
};

步骤6：消息分发和处理系统

设计思路：实现类型安全的消息分发机制，支持多种消息类型的并行处理。

技术选型理由：

类型化消息处理提高代码安全性
错误隔离防止单个处理器影响整体
高性能的消息路由机制

实现原理：使用消息类型作为路由键，将消息分发到对应的处理器集合。

const messageHandlers = new Map<string, Set<MessageHandler>>();

const triggerMessageHandlers = (type: string, data: any): void => {
  const handlers = messageHandlers.get(type);
  if (handlers) {
    handlers.forEach((handler) => {
      try {
        handler(data);
      } catch (error) {
        console.error(`消息处理器执行失败 (${type}):`, error);
      }
    });
  }
};

const on = <T = any>(type: string, handler: MessageHandler<T>): void => {
  if (!messageHandlers.has(type)) {
    messageHandlers.set(type, new Set());
  }
  messageHandlers.get(type)!.add(handler as MessageHandler);
};

const off = (type: string, handler?: MessageHandler): void => {
  const handlers = messageHandlers.get(type);
  if (handlers) {
    if (handler) {
      handlers.delete(handler);
    } else {
      handlers.clear();
    }
  }
};

步骤7：统计信息和性能监控

设计思路：提供详细的连接统计信息，便于监控和故障诊断。

技术选型理由：

全面的性能指标收集
实时状态监控能力
便于集成监控系统

实现原理：在关键操作点记录统计信息，提供实时性能数据。

const stats: WebSocketStats = {
  connectCount: 0,
  disconnectCount: 0,
  reconnectCount: 0,
  sentMessages: 0,
  receivedMessages: 0,
};

const getStats = (): WebSocketStats => {
  const result: WebSocketStats = { ...stats };

  if (config.timeGradient.enabled) {
    const gradientStats = timeGradient.getStats();
    result.timeGradientStats = {
      currentHeartbeatInterval: gradientStats.currentInterval,
      currentReconnectInterval: config.reconnectInterval * Math.pow(2, reconnectAttempts),
      averageLatency: gradientStats.averageLatency,
      stabilityScore: gradientStats.stabilityScore,
      recentConnections: timeGradient['timeRecords'],
    };
  }

  return result;
};

完整可运行的最终代码版本

整合以上所有步骤，提供完整的WebSocket Hook实现：

/**
 * 完整的WebSocket Hook实现
 */
export const useWebsocket = (options: WebSocketOptions): WebSocketHook => {
  // 配置合并
  const config = {
    ...DEFAULT_OPTIONS,
    ...options,
  };

  // 内部状态初始化
  let ws: WebSocket | null = null;
  let heartbeatTimer: NodeJS.Timeout | null = null;
  let heartbeatTimeoutTimer: NodeJS.Timeout | null = null;
  let reconnectTimer: NodeJS.Timeout | null = null;
  let reconnectAttempts = 0;
  let isManualClose = false;
  let lastHeartbeatTime = 0;
  let lastHeartbeatSentTime = 0;

  // 时间梯度计算器
  const timeGradient = new TimeGradientCalculator(
    config.timeGradient as Required<WebSocketOptions['timeGradient']>
  );

  // 消息处理器映射
  const messageHandlers = new Map<string, Set<MessageHandler>>();

  // 统计信息
  const stats: WebSocketStats = {
    connectCount: 0,
    disconnectCount: 0,
    reconnectCount: 0,
    sentMessages: 0,
    receivedMessages: 0,
  };

  // 实现所有步骤的函数...
  // [这里包含步骤4-7的所有函数实现]

  // 初始化
  if (config.autoConnect) {
    connect();
  }

  // 返回Hook实例
  return {
    get readyState() { return getReadyState(); },
    get isConnected() { return getIsConnected(); },
    connect,
    close: (code = 1000, reason = 'Normal closure') => {
      isManualClose = true;
      if (reconnectTimer) clearTimeout(reconnectTimer);
      if (ws) ws.close(code, reason);
    },
    send,
    on,
    off,
    getStats,
  };
};

技术实现要点总结

模块化设计：每个功能模块独立实现，便于测试和维护
类型安全：完整的TypeScript类型定义，减少运行时错误
性能优化：智能算法动态调整参数，避免资源浪费
错误恢复：完善的错误处理和自动重连机制
可观测性：详细的统计信息便于监控和调试

这个分步实现方案确保了代码的可读性、可维护性和可扩展性，每个步骤都可以独立测试和验证。

/**
 * WebSocket通用Hook
 * 提供完整的WebSocket连接管理，包括心跳检测、重连策略、消息类型注册等功能
 *
 * @remarks
 * 该Hook实现了以下核心功能：
 * - 自动重连机制，支持最大重连次数和指数退避策略
 * - 智能心跳检测，支持自适应心跳间隔调整
 * - 消息类型注册和分发机制
 * - 连接状态监控和统计信息收集
 * - 时间梯度优化算法，根据网络状况动态调整参数
 *
 * @example
 * ```typescript
 * const ws = useWebsocket({
 *   url: 'ws://localhost:8080',
 *   heartbeatInterval: 30000,
 *   maxReconnectAttempts: 5
 * });
 *
 * ws.on('message', (data) => console.log(data));
 * ws.send({ action: 'ping' });
 * ```
 */

/**
 * WebSocket配置选项接口
 *
 * @remarks
 * 该接口定义了WebSocket连接的所有可配置参数，包括连接参数、重连策略、心跳检测等
 * 所有参数都有合理的默认值，用户可以根据需要覆盖
 *
 * @property {string} url - WebSocket服务器地址，必需参数
 * @property {string|string[]} [protocols] - WebSocket子协议数组，默认为空
 * @property {number} [heartbeatInterval=30000] - 心跳间隔时间（毫秒），默认30秒
 * @property {number} [heartbeatTimeout=10000] - 心跳超时时间（毫秒），默认10秒
 * @property {number} [maxReconnectAttempts=5] - 最大重连次数，默认5次
 * @property {number} [reconnectInterval=3000] - 重连间隔时间（毫秒），默认3秒
 * @property {number} [reconnectDelay=1000] - 初始重连延迟（毫秒），默认1秒
 * @property {boolean} [autoConnect=true] - 是否自动连接，默认true
 * @property {number} [connectTimeout=10000] - 连接超时时间（毫秒），默认10秒
 * @property {Object} [timeGradient] - 时间梯度配置，用于智能参数调整
 * @property {boolean} [timeGradient.enabled=true] - 是否启用时间梯度优化
 * @property {number} [timeGradient.windowSize=60000] - 梯度计算窗口大小（毫秒）
 * @property {number} [timeGradient.minInterval=1000] - 最小时间间隔（毫秒）
 * @property {number} [timeGradient.maxInterval=60000] - 最大时间间隔（毫秒）
 * @property {number} [timeGradient.smoothingFactor=0.7] - 梯度平滑因子（0-1）
 */
export interface WebSocketOptions {
  /** WebSocket服务器地址 */
  url: string;
  /** 协议数组，默认为空 */
  protocols?: string | string[];
  /** 心跳间隔时间（毫秒），默认30秒 */
  heartbeatInterval?: number;
  /** 心跳超时时间（毫秒），默认10秒 */
  heartbeatTimeout?: number;
  /** 最大重连次数，默认5次 */
  maxReconnectAttempts?: number;
  /** 重连间隔时间（毫秒），默认3秒 */
  reconnectInterval?: number;
  /** 初始重连延迟（毫秒），默认1秒 */
  reconnectDelay?: number;
  /** 是否自动连接，默认true */
  autoConnect?: boolean;
  /** 连接超时时间（毫秒），默认10秒 */
  connectTimeout?: number;
  /** 时间梯度配置 */
  timeGradient?: {
    /** 是否启用时间梯度优化，默认true */
    enabled?: boolean;
    /** 梯度计算窗口大小（毫秒），默认60000 */
    windowSize?: number;
    /** 最小时间间隔（毫秒），默认1000 */
    minInterval?: number;
    /** 最大时间间隔（毫秒），默认60000 */
    maxInterval?: number;
    /** 梯度平滑因子（0-1），默认0.7 */
    smoothingFactor?: number;
  };
}

/**
 * 消息处理器函数类型定义
 *
 * @remarks
 * 该类型定义了处理WebSocket消息的回调函数签名
 * 用户可以通过注册不同类型的消息处理器来处理特定类型的消息
 *
 * @template T - 消息数据类型，默认为any
 * @param {T} data - 接收到的消息数据
 * @returns {void}
 *
 * @example
 * ```typescript
 * const messageHandler: MessageHandler<MyMessageType> = (data) => {
 *   console.log('收到消息:', data);
 * };
 * ```
 */
export interface MessageHandler<T = any> {
  (data: T): void;
}

/**
 * WebSocket Hook接口定义
 *
 * @remarks
 * 该接口定义了WebSocket Hook的所有公共方法，用户可以通过这些方法控制WebSocket连接
 * 所有方法都是线程安全的，可以在任何地方调用
 *
 * @property {number} readyState - 当前WebSocket连接状态，只读属性
 * @property {boolean} isConnected - 是否已连接，只读属性
 *
 * @method connect - 建立WebSocket连接
 * @method close - 关闭WebSocket连接
 * @method send - 发送消息
 * @method on - 注册消息处理器
 * @method off - 注销消息处理器
 * @method getStats - 获取连接统计信息
 * @method updateTimeGradient - 动态调整时间梯度配置
 * @method recalculateTimeGradient - 手动触发时间梯度重新计算
 */
export interface WebSocketHook {
  /**
   * 连接状态
   * @returns {number} WebSocket连接状态，对应WebSocketState枚举值
   */
  readonly readyState: number;

  /**
   * 是否已连接
   * @returns {boolean} 如果连接状态为OPEN则返回true，否则返回false
   */
  readonly isConnected: boolean;

  /**
   * 连接WebSocket
   * @returns {void}
   * @remarks 如果连接正在进行中，该方法会跳过重复连接
   */
  connect(): void;

  /**
   * 关闭WebSocket连接
   * @param {number} [code=1000] - 关闭代码，默认1000（正常关闭）
   * @param {string} [reason='Normal closure'] - 关闭原因
   * @returns {void}
   * @remarks 手动关闭后不会触发自动重连机制
   */
  close(code?: number, reason?: string): void;

  /**
   * 发送消息
   * @template T - 消息数据类型
   * @param {T} message - 要发送的消息对象
   * @param {string} [type='default'] - 消息类型，用于消息分发
   * @returns {boolean} 发送成功返回true，失败返回false
   * @remarks 消息会被自动包装为JSON格式，并添加type字段
   */
  send<T = any>(message: T, type?: string): boolean;

  /**
   * 注册消息处理器
   * @template T - 消息数据类型
   * @param {string} type - 消息类型
   * @param {MessageHandler<T>} handler - 消息处理函数
   * @returns {void}
   * @remarks 可以为同一消息类型注册多个处理器
   */
  on<T = any>(type: string, handler: MessageHandler<T>): void;

  /**
   * 注销消息处理器
   * @param {string} type - 消息类型
   * @param {MessageHandler} [handler] - 要注销的处理器函数，不传则注销该类型所有处理器
   * @returns {void}
   */
  off(type: string, handler?: MessageHandler): void;

  /**
   * 获取连接统计信息
   * @returns {WebSocketStats} 连接统计信息对象
   */
  getStats(): WebSocketStats;

  /**
   * 动态调整时间梯度配置
   * @param {Partial<WebSocketOptions['timeGradient']>} config - 新的时间梯度配置
   * @returns {void}
   * @remarks 配置更新后会重新创建时间梯度计算器
   */
  updateTimeGradient(config: Partial<WebSocketOptions['timeGradient']>): void;

  /**
   * 手动触发时间梯度重新计算
   * @returns {void}
   * @remarks 强制重新计算最优时间间隔，并重新启动心跳检测
   */
  recalculateTimeGradient(): void;
}

/**
 * WebSocket连接统计信息接口
 *
 * @remarks
 * 该接口定义了WebSocket连接的统计信息，用于监控连接状态和性能指标
 * 统计信息包括连接次数、消息数量、时间梯度优化数据等
 *
 * @property {number} connectCount - 连接成功次数
 * @property {number} disconnectCount - 连接断开次数
 * @property {number} reconnectCount - 自动重连次数
 * @property {number} sentMessages - 发送消息总数
 * @property {number} receivedMessages - 接收消息总数
 * @property {Date} [lastConnectTime] - 最后连接成功时间
 * @property {Date} [lastDisconnectTime] - 最后连接断开时间
 * @property {Object} [timeGradientStats] - 时间梯度统计信息（仅当启用时间梯度优化时存在）
 * @property {number} timeGradientStats.currentHeartbeatInterval - 当前心跳间隔（毫秒）
 * @property {number} timeGradientStats.currentReconnectInterval - 当前重连间隔（毫秒）
 * @property {number} timeGradientStats.averageLatency - 平均网络延迟（毫秒）
 * @property {number} timeGradientStats.stabilityScore - 连接稳定性评分（0-100，越高越稳定）
 * @property {number[]} timeGradientStats.recentConnections - 最近连接时间记录（时间戳数组）
 */
export interface WebSocketStats {
  /** 连接次数 */
  connectCount: number;
  /** 断开次数 */
  disconnectCount: number;
  /** 重连次数 */
  reconnectCount: number;
  /** 发送消息数量 */
  sentMessages: number;
  /** 接收消息数量 */
  receivedMessages: number;
  /** 最后连接时间 */
  lastConnectTime?: Date;
  /** 最后断开时间 */
  lastDisconnectTime?: Date;
  /** 时间梯度统计信息 */
  timeGradientStats?: {
    /** 当前心跳间隔 */
    currentHeartbeatInterval: number;
    /** 当前重连间隔 */
    currentReconnectInterval: number;
    /** 平均网络延迟 */
    averageLatency: number;
    /** 连接稳定性评分（0-100） */
    stabilityScore: number;
    /** 最近连接时间记录 */
    recentConnections: number[];
  };
}

/**
 * WebSocket连接状态枚举
 *
 * @remarks
 * 该枚举定义了WebSocket连接的四种标准状态，对应WebSocket API的readyState属性
 *
 * @enum {number}
 * @property {number} CONNECTING=0 - 连接正在进行中
 * @property {number} OPEN=1 - 连接已建立，可以通信
 * @property {number} CLOSING=2 - 连接正在关闭中
 * @property {number} CLOSED=3 - 连接已关闭或无法打开
 */
export enum WebSocketState {
  CONNECTING = 0,
  OPEN = 1,
  CLOSING = 2,
  CLOSED = 3,
}

/** 心跳消息类型常量*/
const HEARTBEAT_TYPE = '__heartbeat__';

/**
 * 默认配置常量
 *
 * @remarks
 * 该常量定义了WebSocket连接的所有默认配置参数
 * 当用户未提供相应配置时，将使用这些默认值
 *
 * @type {Required<Omit<WebSocketOptions, 'url' | 'protocols'>>}
 * @property {number} heartbeatInterval=30000 - 默认心跳间隔30秒
 * @property {number} heartbeatTimeout=10000 - 默认心跳超时10秒
 * @property {number} maxReconnectAttempts=5 - 默认最大重连次数5次
 * @property {number} reconnectInterval=3000 - 默认重连间隔3秒
 * @property {number} reconnectDelay=1000 - 默认初始重连延迟1秒
 * @property {boolean} autoConnect=true - 默认自动连接
 * @property {number} connectTimeout=10000 - 默认连接超时10秒
 * @property {Object} timeGradient - 默认时间梯度配置
 * @property {boolean} timeGradient.enabled=true - 默认启用时间梯度优化
 * @property {number} timeGradient.windowSize=60000 - 默认计算窗口60秒
 * @property {number} timeGradient.minInterval=1000 - 默认最小间隔1秒
 * @property {number} timeGradient.maxInterval=60000 - 默认最大间隔60秒
 * @property {number} timeGradient.smoothingFactor=0.7 - 默认平滑因子0.7
 */
const DEFAULT_OPTIONS: Required<Omit<WebSocketOptions, 'url' | 'protocols'>> = {
  heartbeatInterval: 30000,
  heartbeatTimeout: 10000,
  maxReconnectAttempts: 5,
  reconnectInterval: 3000,
  reconnectDelay: 1000,
  autoConnect: true,
  connectTimeout: 10000,
  timeGradient: {
    enabled: true,
    windowSize: 60000,
    minInterval: 1000,
    maxInterval: 60000,
    smoothingFactor: 0.7,
  },
};

/**
 * 时间梯度计算器类
 * 
 * @remarks
 * 该类实现了自适应时间间隔优化算法，根据网络状况动态调整心跳和重连间隔
 * 核心算法基于时间记录的统计分析和网络延迟评估
 * 
 * @example
 * ```typescript
 * const calculator = new TimeGradientCalculator({
 *   windowSize: 60000,
 *   minInterval: 1000,
 *   maxInterval: 60000,
 *   smoothingFactor: 0.7
 * });
 * 
 * calculator.addRecord(Date.now(), 150);
 * const optimalInterval = calculator.getCurrentInterval();
 * ```
 */
class TimeGradientCalculator {
  /** 计算窗口大小（毫秒），用于限制时间记录的范围 */
  private windowSize: number;

  /** 最小时间间隔（毫秒），防止间隔过短 */
  private minInterval: number;

  /** 最大时间间隔（毫秒），防止间隔过长 */
  private maxInterval: number;

  /** 平滑因子（0-1），用于平滑间隔变化，避免剧烈波动 */
  private smoothingFactor: number;

  /** 时间记录数组，存储连接成功的时间戳 */
  private timeRecords: number[] = [];

  /** 延迟记录数组，存储网络延迟数据 */
  private latencyRecords: number[] = [];

  /** 当前计算出的最优时间间隔 */
  private currentInterval: number;

  /**
   * 构造函数
   * @param config - 时间梯度配置参数
   * @remarks 初始化计算器参数并设置默认间隔
   */
  constructor(config: Required<WebSocketOptions['timeGradient']>) {
    this.windowSize = config!.windowSize;
    this.minInterval = config!.minInterval;
    this.maxInterval = config!.maxInterval;
    this.smoothingFactor = config!.smoothingFactor;
    this.currentInterval = config!.minInterval;
  }

  /**
   * 添加时间记录
   * @param timestamp - 时间戳
   * @param latency - 网络延迟（可选）
   * @remarks 添加记录后会自动清理过期数据并重新计算最优间隔
   */
  addRecord(timestamp: number, latency?: number): void {
    // 添加时间记录
    this.timeRecords.push(timestamp);

    // 添加延迟记录
    if (latency !== undefined) {
      this.latencyRecords.push(latency);
    }

    // 清理过期记录
    this.cleanupRecords();

    // 计算新的时间间隔
    this.calculateOptimalInterval();
  }

  /**
   * 清理过期记录
   * @remarks 移除超出时间窗口的记录，保持数据时效性
   */
  private cleanupRecords(): void {
    const now = Date.now();
    const cutoff = now - this.windowSize;

    // 清理时间记录
    this.timeRecords = this.timeRecords.filter((time) => time >= cutoff);

    // 清理延迟记录（保持与时间记录同步）
    if (this.latencyRecords.length > this.timeRecords.length) {
      this.latencyRecords = this.latencyRecords.slice(-this.timeRecords.length);
    }
  }

  /**
   * 计算最优时间间隔
   * @remarks 基于时间记录的统计分析和网络延迟评估计算自适应间隔
   */
  private calculateOptimalInterval(): void {
    if (this.timeRecords.length < 2) {
      this.currentInterval = this.minInterval;
      return;
    }

    // 缓存计算结果，避免重复计算
    const lastRecord = this.timeRecords[this.timeRecords.length - 1];
    const secondLastRecord = this.timeRecords[this.timeRecords.length - 2];

    // 如果时间间隔很短，避免频繁计算
    if (lastRecord - secondLastRecord < 100) {
      return;
    }

    // 计算时间间隔的变异系数
    const intervals: number[] = [];
    for (let i = 1; i < this.timeRecords.length; i++) {
      intervals.push(this.timeRecords[i] - this.timeRecords[i - 1]);
    }

    const mean = intervals.reduce((sum, val) => sum + val, 0) / intervals.length;
    const variance =
      intervals.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / intervals.length;
    const coefficientOfVariation = Math.sqrt(variance) / mean;

    // 计算平均延迟
    const avgLatency =
      this.latencyRecords.length > 0
        ? this.latencyRecords.reduce((sum, val) => sum + val, 0) / this.latencyRecords.length
        : 0;

    // 基于变异系数和延迟计算自适应间隔
    let adaptiveInterval = mean;

    // 高变异系数表示不稳定，增加间隔
    if (coefficientOfVariation > 0.5) {
      adaptiveInterval *= 1 + coefficientOfVariation;
    }

    // 高延迟时适当增加间隔
    if (avgLatency > 1000) {
      adaptiveInterval *= 1 + Math.min(avgLatency / 5000, 2);
    }

    // 应用平滑因子
    this.currentInterval = Math.round(
      this.smoothingFactor * adaptiveInterval + (1 - this.smoothingFactor) * this.currentInterval
    );

    // 限制在最小和最大间隔之间
    this.currentInterval = Math.max(
      this.minInterval,
      Math.min(this.maxInterval, this.currentInterval)
    );
  }

  /**
   * 获取当前最优间隔
   * @returns 当前计算出的最优时间间隔（毫秒）
   */
  getCurrentInterval(): number {
    return this.currentInterval;
  }

  /**
   * 获取连接稳定性评分（0-100）
   * @returns 稳定性评分，越高表示连接越稳定
   */
  getStabilityScore(): number {
    if (this.timeRecords.length < 2) return 100;

    const intervals: number[] = [];
    for (let i = 1; i < this.timeRecords.length; i++) {
      intervals.push(this.timeRecords[i] - this.timeRecords[i - 1]);
    }

    const mean = intervals.reduce((sum, val) => sum + val, 0) / intervals.length;
    const variance =
      intervals.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / intervals.length;
    const coefficientOfVariation = Math.sqrt(variance) / mean;

    // 变异系数越小，稳定性越高
    return Math.max(0, Math.min(100, Math.round(100 * (1 - Math.min(coefficientOfVariation, 1)))));
  }

  /**
   * 获取平均延迟
   * @returns 平均网络延迟（毫秒）
   */
  getAverageLatency(): number {
    return this.latencyRecords.length > 0
      ? Math.round(
          this.latencyRecords.reduce((sum, val) => sum + val, 0) / this.latencyRecords.length
        )
      : 0;
  }

  /**
   * 获取统计信息
   * @returns 包含当前间隔、稳定性评分、平均延迟和记录数量的统计对象
   */
  getStats() {
    return {
      currentInterval: this.currentInterval,
      stabilityScore: this.getStabilityScore(),
      averageLatency: this.getAverageLatency(),
      recordCount: this.timeRecords.length,
    };
  }
}

/**
 * 创建WebSocket Hook
 * @param options WebSocket配置选项
 * @returns WebSocketHook实例
 * @remarks 该函数是WebSocket Hook的核心实现，提供了完整的连接管理功能
 */
export const useWebsocket = (options: WebSocketOptions): WebSocketHook => {
  // 合并配置
  const config = {
    ...DEFAULT_OPTIONS,
    ...options,
  };

  // 内部状态
  let ws: WebSocket | null = null;
  let heartbeatTimer: NodeJS.Timeout | null = null;
  let heartbeatTimeoutTimer: NodeJS.Timeout | null = null;
  let reconnectTimer: NodeJS.Timeout | null = null;
  let reconnectAttempts = 0;
  let isManualClose = false;
  let lastHeartbeatTime = 0;
  let lastHeartbeatSentTime = 0;

  // 时间梯度计算器
  const timeGradient = new TimeGradientCalculator(
    config.timeGradient as Required<WebSocketOptions['timeGradient']>
  );

  // 消息处理器映射
  const messageHandlers = new Map<string, Set<MessageHandler>>();

  // 统计信息
  const stats: WebSocketStats = {
    connectCount: 0,
    disconnectCount: 0,
    reconnectCount: 0,
    sentMessages: 0,
    receivedMessages: 0,
  };

  /**
   * 获取当前连接状态
   */
  const getReadyState = (): number => {
    return ws?.readyState ?? WebSocketState.CLOSED;
  };

  /**
   * 检查是否已连接
   */
  const getIsConnected = (): boolean => {
    return getReadyState() === WebSocketState.OPEN;
  };

  /**
   * 发送心跳包
   * @remarks 心跳机制用于检测连接是否存活，防止连接意外断开
   */
  const sendHeartbeat = (): void => {
    if (!getIsConnected()) return;

    const heartbeatMessage = {
      type: HEARTBEAT_TYPE,
      timestamp: Date.now(),
    };

    if (send(heartbeatMessage)) {
      lastHeartbeatSentTime = Date.now();

      // 设置心跳超时检查
      if (heartbeatTimeoutTimer) {
        clearTimeout(heartbeatTimeoutTimer);
      }

      // 使用时间梯度计算器获取最优超时时间
      const optimalTimeout = config.timeGradient.enabled
        ? Math.max(config.heartbeatTimeout, timeGradient.getCurrentInterval() * 0.3)
        : config.heartbeatTimeout;

      heartbeatTimeoutTimer = setTimeout(() => {
        console.warn('WebSocket心跳超时，尝试重连');
        handleDisconnect();
      }, optimalTimeout);
    }
  };

  /**
   * 启动心跳检测
   * @remarks 根据网络状况动态调整心跳间隔，实现智能心跳检测
   */
  const startHeartbeat = (): void => {
    stopHeartbeat();

    // 使用时间梯度计算器获取最优心跳间隔
    const optimalInterval = config.timeGradient.enabled
      ? timeGradient.getCurrentInterval()
      : config.heartbeatInterval;

    heartbeatTimer = setInterval(() => {
      sendHeartbeat();
    }, optimalInterval);

    // 立即发送第一次心跳
    sendHeartbeat();
  };

  /**
   * 停止心跳检测
   */
  const stopHeartbeat = (): void => {
    if (heartbeatTimer) {
      clearInterval(heartbeatTimer);
      heartbeatTimer = null;
    }
    if (heartbeatTimeoutTimer) {
      clearTimeout(heartbeatTimeoutTimer);
      heartbeatTimeoutTimer = null;
    }
  };

  /**
   * 处理连接断开
   * @remarks 实现智能重连策略，根据网络状况动态调整重连间隔
   */
  const handleDisconnect = (): void => {
    stopHeartbeat();

    if (isManualClose) {
      return;
    }

    stats.disconnectCount++;
    stats.lastDisconnectTime = new Date();

    // 添加时间记录用于梯度计算
    timeGradient.addRecord(Date.now());

    // 自动重连逻辑
    if (reconnectAttempts < config.maxReconnectAttempts) {
      reconnectAttempts++;
      stats.reconnectCount++;

      // 使用时间梯度计算器获取最优重连间隔
      const optimalReconnectInterval = config.timeGradient.enabled
        ? Math.min(
            config.reconnectInterval * Math.pow(2, reconnectAttempts - 1),
            timeGradient.getCurrentInterval()
          )
        : config.reconnectInterval * Math.pow(2, reconnectAttempts - 1);

      console.log(`WebSocket连接断开，${optimalReconnectInterval}ms后尝试第${reconnectAttempts}次重连`);

      reconnectTimer = setTimeout(() => {
        connect();
      }, optimalReconnectInterval);
    } else {
      console.error('WebSocket重连次数已达上限，停止重连');
    }
  };

  /**
   * 建立WebSocket连接
   * @remarks 实现智能连接策略，包括连接超时处理和状态管理
   */
  const connect = (): void => {
    // 如果连接正在进行中，避免重复连接
    if (ws?.readyState === WebSocketState.CONNECTING) {
      console.warn('WebSocket连接正在进行中，跳过重复连接');
      return;
    }

    // 清理现有连接
    if (ws) {
      ws.close();
      ws = null;
    }

    try {
      ws = new WebSocket(config.url, config.protocols);
      isManualClose = false;

      // 设置连接超时
      const connectTimeoutTimer = setTimeout(() => {
        if (ws?.readyState === WebSocketState.CONNECTING) {
          console.error('WebSocket连接超时');
          ws.close();
          handleDisconnect();
        }
      }, config.connectTimeout);

      ws.onopen = (event) => {
        clearTimeout(connectTimeoutTimer);
        console.log('WebSocket连接成功');

        stats.connectCount++;
        stats.lastConnectTime = new Date();
        reconnectAttempts = 0;

        // 添加时间记录用于梯度计算
        timeGradient.addRecord(Date.now());

        // 启动心跳检测
        startHeartbeat();

        // 触发连接成功事件
        triggerMessageHandlers('open', event);
      };

      ws.onclose = (event) => {
        console.log(`WebSocket连接关闭，代码: ${event.code}, 原因: ${event.reason}`);
        ws = null;

        if (!isManualClose) {
          handleDisconnect();
        }

        // 触发连接关闭事件
        triggerMessageHandlers('close', event);
      };

      ws.onerror = (event) => {
        console.error('WebSocket连接错误', event);
        // 触发错误事件
        triggerMessageHandlers('error', event);
      };

      ws.onmessage = (event) => {
        stats.receivedMessages++;

        try {
          const data = JSON.parse(event.data);

          // 处理心跳响应
          if (data.type === HEARTBEAT_TYPE) {
            lastHeartbeatTime = Date.now();
            const latency = lastHeartbeatTime - data.timestamp;
            timeGradient.addRecord(Date.now(), latency);
            return;
          }

          // 分发消息到对应的处理器
          triggerMessageHandlers(data.type || 'default', data);
          triggerMessageHandlers('message', data);

        } catch (error) {
          console.error('WebSocket消息解析失败', error);
          triggerMessageHandlers('error', error);
        }
      };

    } catch (error) {
      console.error('WebSocket连接创建失败', error);
      handleDisconnect();
    }
  };

  /**
   * 触发消息处理器
   * @param type 消息类型
   * @param data 消息数据
   */
  const triggerMessageHandlers = (type: string, data: any): void => {
    const handlers = messageHandlers.get(type);
    if (handlers) {
      handlers.forEach((handler) => {
        try {
          handler(data);
        } catch (error) {
          console.error(`消息处理器执行失败 (${type}):`, error);
        }
      });
    }
  };

  /**
   * 发送消息
   * @param message 消息对象
   * @param type 消息类型
   * @returns 发送是否成功
   */
  const send = <T = any>(message: T, type: string = 'default'): boolean => {
    if (!getIsConnected()) {
      console.warn('WebSocket未连接，消息发送失败');
      return false;
    }

    try {
      const messageWithType = {
        ...message,
        type,
        timestamp: Date.now(),
      };

      ws!.send(JSON.stringify(messageWithType));
      stats.sentMessages++;
      return true;
    } catch (error) {
      console.error('WebSocket消息发送失败', error);
      return false;
    }
  };

  /**
   * 注册消息处理器
   * @param type 消息类型
   * @param handler 处理器函数
   */
  const on = <T = any>(type: string, handler: MessageHandler<T>): void => {
    if (!messageHandlers.has(type)) {
      messageHandlers.set(type, new Set());
    }
    messageHandlers.get(type)!.add(handler as MessageHandler);
  };

  /**
   * 注销消息处理器
   * @param type 消息类型
   * @param handler 处理器函数
   */
  const off = (type: string, handler?: MessageHandler): void => {
    const handlers = messageHandlers.get(type);
    if (handlers) {
      if (handler) {
        handlers.delete(handler);
      } else {
        handlers.clear();
      }
      if (handlers.size === 0) {
        messageHandlers.delete(type);
      }
    }
  };

  /**
   * 获取统计信息
   * @returns 连接统计信息
   */
  const getStats = (): WebSocketStats => {
    const result: WebSocketStats = { ...stats };

    if (config.timeGradient.enabled) {
      const gradientStats = timeGradient.getStats();
      result.timeGradientStats = {
        currentHeartbeatInterval: gradientStats.currentInterval,
        currentReconnectInterval: Math.min(
          config.reconnectInterval * Math.pow(2, reconnectAttempts),
          gradientStats.currentInterval
        ),
        averageLatency: gradientStats.averageLatency,
        stabilityScore: gradientStats.stabilityScore,
        recentConnections: timeGradient['timeRecords'],
      };
    }

    return result;
  };

  /**
   * 更新时间梯度配置
   * @param newConfig 新的时间梯度配置
   */
  const updateTimeGradient = (newConfig: Partial<WebSocketOptions['timeGradient']>): void => {
    if (newConfig.enabled !== undefined) {
      config.timeGradient.enabled = newConfig.enabled;
    }

    // 重新创建时间梯度计算器
    const mergedConfig = {
      ...config.timeGradient,
      ...newConfig,
    } as Required<WebSocketOptions['timeGradient']>;

    // 更新计算器实例
    Object.assign(timeGradient, new TimeGradientCalculator(mergedConfig));

    // 重新启动心跳检测以应用新配置
    if (getIsConnected()) {
      startHeartbeat();
    }
  };

  /**
   * 手动触发时间梯度重新计算
   */
  const recalculateTimeGradient = (): void => {
    // 强制重新计算
    timeGradient.addRecord(Date.now());

    // 重新启动心跳检测
    if (getIsConnected()) {
      startHeartbeat();
    }
  };

  // 初始化
  if (config.autoConnect) {
    connect();
  }

  // 返回WebSocket Hook实例
  return {
    get readyState() {
      return getReadyState();
    },
    get isConnected() {
      return getIsConnected();
    },
    connect,
    close: (code = 1000, reason = 'Normal closure') => {
      isManualClose = true;
      if (reconnectTimer) {
        clearTimeout(reconnectTimer);
        reconnectTimer = null;
      }
      if (ws) {
        ws.close(code, reason);
      }
    },
    send,
    on,
    off,
    getStats,
    updateTimeGradient,
    recalculateTimeGradient,
  };
};

关键实现部分注释说明

1. 时间梯度优化算法

/**
 * 时间梯度计算器 - 核心智能算法
 * 
 * 该算法通过分析历史连接数据，动态调整心跳和重连间隔：
 * - 稳定性评估：基于时间间隔的变异系数评估连接稳定性
 * - 延迟感知：根据网络延迟调整间隔参数
 * - 自适应调整：使用平滑因子避免间隔剧烈波动
 * - 频率限制：避免频繁计算导致的性能问题
 */

2. 智能重连策略

/**
 * 指数退避重连策略
 * 
 * 特点：
 * - 渐进式延迟：每次重连间隔指数增长（1s, 2s, 4s, 8s...）
 * - 最大限制：防止无限重连，设置最大重连次数
 * - 智能调整：结合时间梯度算法动态优化重连间隔
 * - 手动控制：用户主动关闭时不触发自动重连
 */

3. 心跳检测机制

/**
 * 自适应心跳检测
 * 
 * 实现原理：
 * - 双向验证：发送心跳包并等待服务器响应
 * - 超时检测：设置合理的心跳超时时间
 * - 延迟测量：通过心跳响应时间测量网络延迟
 * - 动态间隔：根据网络状况智能调整心跳频率
 */

4. 消息分发系统

/**
 * 类型化消息分发
 * 
 * 设计优势：
 * - 类型安全：支持TypeScript类型检查
 * - 灵活注册：支持为不同消息类型注册多个处理器
 * - 错误隔离：单个处理器错误不影响其他处理器
 * - 性能优化：使用Set数据结构提高查找效率
 */

总结

通过本文的详细分析，我们可以看到WebSocket技术在实时通信领域的显著优势：

WebSocket的核心价值

真正的实时性：相比轮询和SSE，WebSocket提供了最低延迟的双向通信
协议效率：避免了HTTP头部开销，显著减少网络带宽消耗
开发体验：现代浏览器原生支持，API简洁易用
性能优化：支持大量并发连接，服务器资源利用率高

实际应用建议

新项目：优先选择WebSocket作为实时通信方案
现有项目：逐步将轮询方案迁移到WebSocket
混合方案：复杂场景可结合WebSocket和SSE使用
兼容性：为不支持WebSocket的浏览器提供降级方案