第一章：Go语言WebSocket开发环境搭建与基础概念

Go语言以其简洁的语法和高效的并发处理能力，在现代网络编程中逐渐成为开发WebSocket服务端的首选语言之一。要开始使用Go进行WebSocket开发，首先需要搭建一个适合的开发环境，并理解WebSocket的基本概念。

开发环境准备

确保你的系统中已经安装了Go运行环境，可以通过以下命令检查：

go version

如果尚未安装，请前往 Go官网 下载并安装对应操作系统的版本。

接下来，推荐使用 go get 安装流行的WebSocket库 gorilla/websocket：

go get github.com/gorilla/websocket

该库封装了WebSocket的底层通信细节，提供了简洁易用的API，是构建WebSocket服务的理想选择。

WebSocket基础概念

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。与传统的 HTTP 请求-响应模式不同，WebSocket 允许客户端与服务器之间双向实时通信。

在Go中，建立WebSocket连接的基本流程如下：

1. 客户端发起一个HTTP请求，要求“升级”为WebSocket连接；
2. 服务器接受请求并完成协议切换；
3. 双方通过 gorilla/websocket 提供的 Upgrader 和 Conn 对象进行消息读写。

下面是一个简单的WebSocket服务端处理函数示例：

package main

import (
    "github.com/gorilla/websocket"
    "net/http"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, _ := upgrader.Upgrade(w, r, nil) // 升级为WebSocket连接
    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            return
        }
        conn.WriteMessage(messageType, p) // 回显收到的消息
    }
}

以上代码定义了一个简单的WebSocket处理函数，它接收客户端的消息并原样返回。这为后续构建更复杂的实时应用打下了基础。

第二章：WebSocket协议原理与Go实现解析

2.1 WebSocket协议握手过程详解与Go语言实现

WebSocket 建立连接的第一步是通过 HTTP 协议进行握手。客户端首先发送一个带有 Upgrade: websocket 请求头的 HTTP GET 请求，服务端识别该请求后，返回 101 Switching Protocols 状态码，完成协议切换。

握手请求与响应示例

客户端请求头示例如下：

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

服务端响应头如下：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9k4RrsGnuuJIh4SLfHMA

使用 Go 实现 WebSocket 握手

下面是一个基于标准库 net/http 实现的简单 WebSocket 握手逻辑：

package main

import (
    "bufio"
    "fmt"
    "net"
    "strings"
)

func handleWebSocket(conn net.Conn) {
    reader := bufio.NewReader(conn)
    request, _ := reader.ReadString('\n')

    // 解析 Sec-WebSocket-Key
    var key string
    for {
        line, _ := reader.ReadString('\n')
        if line == "\r\n" {
            break
        }
        if strings.Contains(line, "Sec-WebSocket-Key") {
            key = strings.TrimSpace(strings.Split(line, ":")[1])
        }
    }

    // 构造响应头
    response := "HTTP/1.1 101 Switching Protocols\r\n" +
        "Upgrade: websocket\r\n" +
        "Connection: Upgrade\r\n" +
        fmt.Sprintf("Sec-WebSocket-Accept: %s\r\n\r\n", computeAcceptKey(key))

    conn.Write([]byte(response))
}

func main() {
    listener, _ := net.Listen("tcp", ":8080")
    for {
        conn, _ := listener.Accept()
        go handleWebSocket(conn)
    }
}

逻辑分析：

• handleWebSocket 函数读取客户端的原始 HTTP 请求；
• 从中提取 Sec-WebSocket-Key 请求头；
• 使用 computeAcceptKey 函数（未展示）对密钥进行处理，生成符合规范的 Sec-WebSocket-Accept；
• 最后将构造好的响应头写回客户端，完成握手。

握手流程图

graph TD
    A[客户端发送HTTP Upgrade请求] --> B[服务端接收并解析请求]
    B --> C[服务端生成响应头]
    C --> D[服务端返回101 Switching Protocols]
    D --> E[WebSocket连接建立]

握手完成后，双方即可通过 WebSocket 协议进行双向通信。

2.2 消息帧结构解析与数据收发机制

在网络通信中，消息帧是数据传输的基本单元，其结构设计直接影响通信效率与可靠性。一个典型的消息帧通常包括以下几个字段：

字段	描述
起始标志	标识帧的开始
消息类型	指明数据用途或操作类型
数据长度	表示数据段的字节长度
数据段	实际传输的有效数据
校验码	用于数据完整性校验
结束标志	标识帧的结束

数据收发流程

在数据发送端，帧结构被封装后通过通信接口传输；接收端则按照预定义格式解析帧内容。以下是一个简单的帧封装示例：

typedef struct {
    uint8_t start_flag;     // 起始标志
    uint8_t msg_type;       // 消息类型
    uint16_t data_length;   // 数据长度
    uint8_t data[256];      // 数据缓冲区
    uint16_t crc;           // 校验码
    uint8_t end_flag;       // 结束标志
} MessageFrame;

逻辑分析如下：

• start_flag 和 end_flag 用于帧边界识别，防止数据粘包；
• msg_type 用于上层协议处理不同类型的请求或响应；
• data_length 控制接收端读取数据的长度；
• crc 用于校验数据完整性，提升通信可靠性。

数据同步机制

为确保收发双方同步，通常采用如下策略：

• 基于超时重传机制：若接收方未在指定时间内返回确认，发送方将重发数据帧；
• 帧序号机制：每个帧附带序号，用于识别重复帧或丢失帧；
• 状态机控制：通过有限状态机管理通信状态，实现自动应答与错误恢复。

通信流程图

graph TD
    A[发送帧请求] --> B{帧是否完整}
    B -->|是| C[计算CRC校验]
    B -->|否| D[丢弃帧并请求重传]
    C --> E[发送帧至接收端]
    E --> F{接收端是否校验成功}
    F -->|是| G[处理数据]
    F -->|否| H[返回错误码]
    G --> I[发送响应帧]

通过上述机制，系统能够实现稳定、高效的数据传输。帧结构的标准化设计为跨平台通信提供了基础，而数据校验与同步机制则显著提升了通信的可靠性与容错能力。

2.3 建立连接与连接状态管理实践

在分布式系统中，建立可靠连接并有效管理连接状态是保障服务通信稳定性的关键环节。连接的建立通常涉及握手协议，如TCP三次握手或基于HTTP/HTTPS的协商机制。

连接状态的生命周期

连接状态通常包括以下几个阶段：

• 初始化（Init）：客户端准备连接资源，进行地址解析和路由选择；
• 建立中（Connecting）：尝试与服务端建立物理或逻辑通道；
• 已建立（Connected）：连接成功，数据可双向传输；
• 断开中（Disconnecting）：主动或被动关闭连接；
• 已断开（Disconnected）：连接释放，资源回收。

状态管理策略

为提升系统鲁棒性，建议采用状态机模式进行连接管理。以下是一个简单的状态机示意图：

graph TD
    A[Init] --> B[Connecting]
    B --> C[Connected]
    C --> D[Disconnecting]
    D --> E[Disconnected]
    E --> A

该模型清晰地定义了连接状态的流转路径，有助于实现状态隔离与异常处理。

2.4 文本消息与二进制消息的处理方式

在网络通信中，消息通常分为文本消息和二进制消息两种类型。文本消息多用于结构化数据交换，如 JSON、XML 等，适用于调试和易读性要求高的场景。

而二进制消息则以字节流形式传输，常用于高效传输大量非结构化数据，如图片、音视频流或序列化对象。

处理方式对比

类型	编码方式	优点	缺点
文本消息	UTF-8	易读、易调试	体积大、解析效率低
二进制消息	自定义协议、Protobuf	高效、压缩率高	不可读、需协议定义

示例代码：WebSocket接收消息

socket.onmessage = function(event) {
    if (typeof event.data === 'string') {
        console.log('收到文本消息:', event.data);
    } else if (event.data instanceof Blob) {
        const reader = new FileReader();
        reader.onload = function() {
            const arrayBuffer = reader.result;
            const dataView = new DataView(arrayBuffer);
            // 解析二进制协议头，例如前4字节为消息类型
            const msgType = dataView.getUint32(0);
            console.log('收到二进制消息，类型:', msgType);
        };
        reader.readAsArrayBuffer(event.data);
    }
};

上述代码展示了如何在 WebSocket 中区分处理文本与二进制消息。通过判断 event.data 的类型，分别进行解析。对于二进制数据，使用 FileReader 转换为 ArrayBuffer 后，借助 DataView 实现灵活的协议解析。

演进趋势

随着实时通信需求的增长，二进制协议（如 Protobuf、Thrift）因其高效性逐渐成为主流。而文本协议则更多用于调试、配置等场景，体现由易用向高效的演进。

2.5 错误处理与连接中断恢复策略

在分布式系统或网络通信中，错误处理和连接中断恢复是保障系统稳定性的关键环节。常见的错误类型包括超时、数据校验失败、网络中断等，每种错误都需要有对应的处理机制。

错误分类与响应策略

错误类型	响应策略
网络超时	重试 + 超时退避机制
数据校验失败	记录日志 + 通知发送方重新发送
连接中断	自动重连 + 会话状态保持

连接恢复流程图

graph TD
    A[连接中断] --> B{是否超过最大重试次数?}
    B -- 是 --> C[终止连接]
    B -- 否 --> D[等待退避时间]
    D --> E[尝试重新连接]
    E --> F{连接成功?}
    F -- 是 --> G[恢复会话状态]
    F -- 否 --> B

重试机制示例代码

import time

def retry_connection(max_retries=3, delay=1):
    attempt = 0
    while attempt < max_retries:
        try:
            # 模拟建立连接
            connect()
            print("连接成功")
            return True
        except ConnectionError:
            print(f"连接失败，第 {attempt + 1} 次重试...")
            attempt += 1
            time.sleep(delay)
    print("连接失败，已达最大重试次数")
    return False

def connect():
    # 模拟连接失败
    raise ConnectionError

逻辑说明：

• max_retries：最大重试次数，防止无限循环；
• delay：每次重试之间的间隔时间，用于缓解服务器压力；
• connect()：模拟连接建立函数，抛出异常表示失败；
• 在捕获异常后进行重试，超过限制后终止连接。

通过合理设计错误响应和连接恢复机制，可以显著提升系统的健壮性和可用性。

第三章：基于Go的WebSocket服务器开发实战

3.1 构建基础WebSocket服务器

在现代实时通信应用中，WebSocket 协议已成为构建双向通信的首选方案。本章将从零开始，构建一个基础的 WebSocket 服务器。

初始化项目环境

首先，我们需要一个运行 Node.js 的环境，并安装 ws 库，这是目前最流行的 WebSocket 服务器库。

npm init -y
npm install ws

编写 WebSocket 服务端代码

以下是一个最基础的 WebSocket 服务器实现：

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
  console.log('Client connected');

  ws.on('message', (message) => {
    console.log(`Received: ${message}`);
    ws.send(`Echo: ${message}`);
  });
});

代码说明：

• WebSocket.Server 创建了一个监听在 8080 端口的 WebSocket 服务；
• connection 事件在客户端连接时触发，ws 是与该客户端的连接对象；
• message 事件监听客户端发送的消息，使用 ws.send() 将收到的消息回传给客户端。

该实现为后续扩展消息广播、身份验证等功能提供了基础结构。

3.2 客户端连接池与消息广播实现

在高并发网络服务中，客户端连接池和消息广播机制是提升系统性能与消息分发效率的关键设计。

连接池优化策略

连接池通过复用已建立的客户端连接，显著减少频繁连接创建与销毁的开销。通常采用对象池模式实现，例如：

type ClientPool struct {
    pool *sync.Pool
}

func (p *ClientPool) Get() *Client {
    return p.pool.Get().(*Client)
}

func (p *ClientPool) Put(client *Client) {
    p.pool.Put(client)
}

上述代码中，sync.Pool是Go语言内置的轻量级对象池，适用于临时对象复用场景。通过Get和Put方法实现连接对象的获取与归还，减少内存分配压力。

消息广播机制设计

消息广播常用于通知所有在线客户端，实现方式包括：

• 遍历连接池，逐一发送
• 使用事件队列异步推送

广播效率直接影响系统吞吐能力，推荐采用异步非阻塞方式。

性能对比

实现方式	内存分配次数	广播延迟	适用场景
原始连接	高	高	低频通信
连接池 + 同步广播	低	中	中等并发
连接池 + 异步广播	低	低	高并发实时通信

在实际部署中，应根据业务负载特征选择合适的实现策略。

3.3 性能优化与高并发场景下的连接管理

在高并发系统中，连接管理是影响整体性能的关键因素之一。频繁创建和销毁数据库或网络连接会导致资源浪费，甚至成为系统瓶颈。为此，连接池技术被广泛应用，以复用已有连接，降低开销。

连接池配置示例（基于HikariCP）

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
config.setMaximumPoolSize(20); // 设置最大连接数
config.setIdleTimeout(30000);  // 空闲超时时间
config.setMaxLifetime(180000); // 连接最大存活时间

HikariDataSource dataSource = new HikariDataSource(config);

逻辑分析：上述代码通过配置 HikariCP 连接池，设定最大连接数、空闲超时和连接生命周期，从而避免频繁创建连接带来的性能损耗。适用于并发请求密集的业务场景。

连接管理策略对比

策略	优点	缺点
单连接模式	实现简单	无法应对并发
每次新建连接	资源隔离性好	性能差，易导致连接风暴
连接池复用	提升响应速度，节省资源	配置不当易引发死锁或泄漏

总结

良好的连接管理机制不仅能提升系统吞吐量，还能增强服务的稳定性。通过合理设置连接池参数、监控连接状态，可以有效支撑高并发场景下的持续服务能力。

第四章：WebSocket客户端开发与交互设计

4.1 构建稳定可靠的WebSocket客户端

在构建WebSocket客户端时，稳定性与重连机制是关键考量因素。一个基础的客户端应具备连接建立、消息收发以及异常处理的能力。

连接管理与重试机制

构建客户端时，需封装连接逻辑并加入自动重连策略：

class ReliableWebSocket {
  constructor(url) {
    this.url = url;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
    this.connect();
  }

  connect() {
    this.socket = new WebSocket(this.url);

    this.socket.onopen = () => {
      console.log('WebSocket connected');
      this.reconnectAttempts = 0;
    };

    this.socket.onclose = (event) => {
      console.log(`Connection closed: ${event.reason}`);
      this.handleReconnect();
    };

    this.socket.onerror = (error) => {
      console.error('WebSocket error:', error);
      this.socket.close();
    };
  }

  handleReconnect() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      setTimeout(() => {
        console.log(`Reconnecting attempt ${this.reconnectAttempts + 1}`);
        this.reconnectAttempts++;
        this.connect();
      }, 1000 * Math.pow(2, this.reconnectAttempts));
    } else {
      console.error('Maximum reconnect attempts reached');
    }
  }
}

逻辑分析：

• connect() 方法用于初始化 WebSocket 连接；
• onopen 在连接成功时重置重连计数器；
• onclose 触发后调用 handleReconnect() 进行指数退避重连；
• onerror 捕获异常并主动关闭连接以触发 onclose；
• handleReconnect() 限制最大重连次数，并采用指数退避策略减少网络压力。

心跳机制保障连接活性

为了防止连接因长时间无数据而断开，可加入心跳包机制：

startHeartbeat(interval = 30000) {
  this.heartbeat = setInterval(() => {
    if (this.socket.readyState === WebSocket.OPEN) {
      this.socket.send(JSON.stringify({ type: 'ping' }));
    }
  }, interval);
}

心跳包定期发送 ping 消息，服务端回应 pong，若未收到回应则触发重连逻辑。

消息队列与状态管理

为保证消息在连接不稳定时不会丢失，客户端应维护一个消息队列，并在连接恢复后重新发送：

sendMessage(message) {
  if (this.socket.readyState === WebSocket.OPEN) {
    this.socket.send(JSON.stringify(message));
  } else {
    this.messageQueue.push(message);
  }
}

flushMessageQueue() {
  while (this.messageQueue.length > 0) {
    const message = this.messageQueue.shift();
    this.socket.send(JSON.stringify(message));
  }
}

结合 onopen 事件调用 flushMessageQueue()，确保连接恢复后消息队列得以清空。

状态管理流程图

使用 Mermaid 展示客户端状态流转：

graph TD
  A[Disconnected] -->|Connect| B[Connecting]
  B -->|Success| C[Connected]
  B -->|Fail| D[Reconnecting]
  C -->|Send Message| E[Message Sent]
  C -->|Close| A
  D -->|Retry| B
  D -->|Max Attempts| F[Connection Failed]

该流程图清晰展示了客户端在不同连接状态下的行为流转，有助于理解整体连接控制逻辑。

---

通过上述机制，一个具备自动重连、心跳检测与消息队列管理的 WebSocket 客户端即可构建完成，为高可用的实时通信打下坚实基础。

4.2 消息编解码与协议封装设计

在分布式系统通信中，消息的编解码与协议封装是保障数据准确传输的关键环节。良好的设计不仅能提升传输效率，还能增强系统的可扩展性和兼容性。

协议结构设计

一个典型的通信协议通常包含以下几个部分：

字段	描述	示例值
魔数	标识协议标识	0x12345678
版本号	支持协议版本迭代	1
消息类型	区分请求、响应或事件	0x01
数据长度	负载长度	256
数据负载	序列化后的业务数据	JSON/Binary

编解码实现示例（Java）

public class MessageCodec {
    public byte[] encode(Message msg) {
        // 将各字段按协议顺序写入字节流
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.putInt(0x12345678);        // 魔数
        buffer.put((byte)1);              // 版本号
        buffer.put(msg.getType());        // 消息类型
        byte[] data = msg.getBodyBytes();
        buffer.putInt(data.length);       // 数据长度
        buffer.put(data);                 // 数据负载
        return buffer.array();
    }
}

上述代码将消息对象按照预定义协议结构序列化为字节数组，便于网络传输。其中魔数用于校验数据合法性，版本号支持协议演进，消息类型用于路由处理逻辑，数据长度用于接收端正确读取负载内容。

4.3 心跳机制与断线重连实现

在长连接通信中，心跳机制用于检测连接状态，确保服务端与客户端之间的连接处于活跃状态。通常通过定时发送轻量级数据包来维持连接。

心跳机制实现示例

setInterval(() => {
  if (socket.readyState === WebSocket.OPEN) {
    socket.send(JSON.stringify({ type: 'ping' }));
  }
}, 5000);

上述代码每5秒发送一次心跳包，socket.readyState === WebSocket.OPEN确保只在连接正常时发送，防止异常中断。

断线重连策略

常见的断线重连策略包括：

• 指数退避算法：重连间隔逐步增大，避免服务端压力集中
• 最大重试次数限制：防止无限循环重连
• 网络状态监听：结合系统网络变化事件触发重连逻辑

重连状态流程图

graph TD
    A[连接中断] --> B{是否达到最大重试次数?}
    B -- 否 --> C[等待N秒后重连]
    C --> D[尝试重新连接]
    D --> E[连接成功?]
    E -- 是 --> F[恢复通信]
    E -- 否 --> C
    B -- 是 --> G[停止重连，提示错误]

4.4 安全通信：TLS加密与身份验证

在现代网络通信中，保障数据传输的机密性和完整性是系统设计的重要目标之一。TLS（Transport Layer Security）协议作为HTTPS的基础，提供了加密传输与身份验证能力，有效防止了中间人攻击和数据篡改。

加密通信的基本流程

TLS协议通过握手阶段完成密钥协商和身份验证，随后使用对称加密算法保护数据流。以下是一个简化版的TLS握手过程示意：

# 伪代码示例：TLS握手流程
def tls_handshake(client, server):
    client_hello = send_client_hello()
    server_hello = server.respond_hello()

    server_cert = server.send_certificate()  # 服务器发送证书
    verify_certificate(server_cert)         # 客户端验证证书有效性

    pre_master_secret = generate_pre_secret()
    encrypted_secret = encrypt_with_pubkey(pre_master_secret, server_pubkey)
    server.receive_secret(encrypted_secret)

    session_key = derive_session_key(pre_master_secret)
    return session_key

逻辑分析说明：

• client_hello 和 server_hello 用于协商协议版本和加密套件；
• server_cert 包含服务器的公钥和身份信息，由可信CA签名；
• 客户端使用服务器公钥加密生成的预主密钥（pre_master_secret），确保只有服务器可解密；
• 双方基于预主密钥派生出相同的会话密钥，用于后续数据加密和完整性验证。

身份验证机制

客户端通过验证服务器证书，确保连接的是合法实体。证书验证包括以下步骤：

• 检查证书是否由受信任的CA签发；
• 验证证书是否在有效期内；
• 校验证书中域名是否匹配目标主机；
• 查询CRL（证书吊销列表）或使用OCSP确认证书未被吊销。

TLS版本演进简表

TLS版本	发布年份	主要改进
TLS 1.0	1999	基于SSL 3.0改进，增强安全性
TLS 1.2	2008	支持现代加密算法（如AES-GCM）
TLS 1.3	2018	简化握手流程，提升性能与安全性

安全通信架构示意图

graph TD
    A[Client] -->|ClientHello| B[Server]
    B -->|ServerHello, Certificate| A
    A -->|Encrypted Pre-Master Secret| B
    A -->|Change Cipher Spec| B
    B -->|Change Cipher Spec| A
    A -->|Application Data| B
    B -->|Application Data| A

该流程图展示了TLS 1.2握手阶段的核心交互过程，确保通信双方在不安全信道上建立安全连接。随着TLS 1.3的普及，握手过程进一步优化，实现0-RTT连接建立，提升性能的同时增强了安全性。

第五章：WebSocket在实时系统中的应用与未来趋势

WebSocket 自诞生以来，因其全双工通信能力，在实时系统中扮演了不可或缺的角色。随着互联网应用对实时性要求的不断提升，WebSocket 已成为构建现代实时系统的关键技术之一。

实时通信的核心价值

WebSocket 提供了客户端与服务器之间持久、低延迟的双向通信。相较于传统的 HTTP 轮询方式，WebSocket 极大地减少了通信延迟与服务器负载。例如，在在线协作编辑系统中，多个用户可以同时编辑文档，所有变更通过 WebSocket 实时同步到所有连接客户端，极大提升了协作效率。

行业落地案例分析

在金融交易系统中，WebSocket 被广泛用于推送实时行情数据。某证券交易平台通过引入 WebSocket，将行情更新延迟从秒级降低至毫秒级，大幅提升了用户体验和交易响应速度。

在智能物联网（IoT）领域，WebSocket 也展现了强大的适应能力。以智能家居控制系统为例，设备状态变更和用户指令通过 WebSocket 实时同步，确保了远程控制的即时响应与数据同步。

与新兴技术的融合趋势

WebSocket 正在与 WebRTC、MQTT 等协议形成互补。在某些实时音视频通信场景中，WebSocket 被用于信令交换，而媒体数据则通过 WebRTC 传输，形成一套完整的实时通信解决方案。

在边缘计算架构中，WebSocket 作为轻量级通信协议，被用于边缘节点与中心服务器之间的状态同步与控制指令下发，提升了整体系统的响应效率。

技术演进与挑战

随着 HTTP/2 和 QUIC 协议的普及，WebSocket 面临着新的竞争与融合机会。尽管其在实时性方面仍具优势，但在连接管理、加密传输和跨平台兼容性方面仍需持续优化。

未来，WebSocket 很可能进一步融入服务网格与微服务架构中，作为实时通信模块的核心组件之一。其在云原生环境下的部署效率和稳定性，也将成为技术演进的重要方向。

场景	优势体现	延迟优化效果
在线协作	多端同步，低延迟	从秒级到毫秒级
金融行情推送	持续连接，减少请求开销	实时更新
IoT 控制系统	双向通信，即时响应	延迟小于 100ms

// WebSocket 简单连接与消息处理示例
const socket = new WebSocket('wss://example.com/socket');

socket.addEventListener('open', () => {
  console.log('WebSocket 连接已建立');
  socket.send('{"type": "subscribe", "channel": "stock_quotes"}');
});

socket.addEventListener('message', event => {
  const data = JSON.parse(event.data);
  console.log(`收到行情数据：${data.symbol} - ${data.price}`);
});

WebSocket 的持续演进，将推动更多实时应用场景的落地。从边缘设备到云端，其在构建高效、稳定、低延迟通信链路中的价值将持续显现。