高性能网络编程：从底层 TCP/UDP Socket 到现代 WebSocket 服务端实现

高性能网络编程：从底层 TCP/UDP Socket 到现代 WebSocket 服务端实现

对于一门以网络服务器起家的技术而言，网络编程无疑是 Node.js 最核心的竞争力之一。

从底层的 TCP/UDP 字节流传输，到上层的 HTTP 及现代 WebSocket 实时双向通信，Node.js 提供了极其强大且轻量级的原生网络模块。本文将带你从底层 Socket 出发，逐步构建高性能的网络服务端应用。

一、 底层基石：使用 net 模块构建高并发 TCP 服务端

在 Node.js 中，net 模块提供了异步的网络包装器，允许我们创建基于 TCP（Transmission Control Protocol）的服务端和客户端。TCP 是一种面向连接的、可靠的、基于字节流的传输层协议。

1. 编写一个基础的 TCP 服务端

以下是一个使用 net 模块实现的生产级雏形服务，支持多客户端连接、数据收发及断开处理：

import net from 'node:net';

const PORT = 8080;
const HOST = '0.0.0.0';

// 创建 TCP 服务端
const server = net.createServer((socket) => {
    // 获取客户端远程地址与端口
    const clientAddress = `${socket.remoteAddress}:${socket.remotePort}`;
    console.log(`[连接建立] 客户端已连接: ${clientAddress}`);

    // 设置数据编码为 utf-8，避免接收到纯 Buffer
    socket.setEncoding('utf8');

    // 监听客户端发送的数据
    socket.on('data', (data) => {
        console.log(`[接收数据] 来自 ${clientAddress}: ${data.trim()}`);
        
        // 回显数据（Echo）或执行业务响应
        socket.write(`Server ACK: ${data}`);
    });

    // 监听客户端断开连接
    socket.on('end', () => {
        console.log(`[连接断开] 客户端主动断开: ${clientAddress}`);
    });

    // 错误处理
    socket.on('error', (err) => {
        console.error(`[Socket 异常] ${clientAddress} 错误:`, err.message);
    });
});

// 启动监听
server.listen(PORT, HOST, () => {
    console.log(`[服务启动] TCP Server 正在监听 ${HOST}:${PORT}`);
});

// 限制最大连接数保护服务器
server.maxConnections = 1500;

2. 核心优化点

• 流式处理（Stream）： net.Socket 继承自 Duplex（双工流），这意味着你可以直接利用 .pipe() 方法将输入流对接至文件、解压模块或其他输出流。
• 背压控制（Backpressure）： 当客户端发送数据的速度远超服务端处理能力时，socket.write() 会返回 false，此时应当暂停读取或等待 drain 事件，防止内存溢出。

二、 追求极致速度：dgram 模块与 UDP 通信

与 TCP 不同，UDP（User Datagram Protocol）是一种无连接的、不可靠但传输极快的协议。它适用于对实时性要求极高、允许少量丢包的场景（如音视频流、局域网设备心跳同步、物联网日志上报等）。

Node.js 提供了 node:dgram 模块来处理 UDP 数据报：

import dgram from 'node:dgram';

const server = dgram.createSocket('udp4');

server.on('error', (err) => {
    console.error(`UDP 服务异常:\n${err.stack}`);
    server.close();
});

server.on('message', (msg, rinfo) => {
    console.log(`收到来自 ${rinfo.address}:${rinfo.port} 的 UDP 报文: ${msg}`);
    
    // 快速响应客户端
    const response = Buffer.from('ACK message received');
    server.send(response, rinfo.port, rinfo.address, (err) => {
        if (err) console.error('发送 UDP 响应失败', err);
    });
});

server.on('listening', () => {
    const address = server.address();
    console.log(`UDP 服务已启动，监听于 ${address.address}:${address.port}`);
});

server.bind(41234);

三、 迈向现代 Web：WebSocket 实时双向通信

虽然 TCP/UDP 非常适合底层物联网或定制协议，但在 Web 浏览器和现代后台管理系统中，我们更依赖 WebSocket。WebSocket 建立在单个 TCP 连接之上，实现了全双工（Full-Duplex）通信，彻底摆脱了传统 HTTP 轮询带来的巨大性能浪费。

在 Node.js 中，最常用的高性能 WebSocket 库是 ws。以下是一个标准的 WebSocket 服务端实现：

import { createServer } from 'node:http';
import { WebSocketServer } from 'ws';

// 1. 创建原生 HTTP 服务
const server = createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('WebSocket Gateway is running.\n');
});

// 2. 挂载 WebSocket 服务端到同一个 HTTP 端口上
const wss = new WebSocketServer({ server });

wss.on('connection', (ws, req) => {
    const ip = req.socket.remoteAddress;
    console.log(`[WS 连接成功] 客户端 IP: ${ip}`);

    ws.on('message', (message) => {
        console.log(`[WS 收到消息]: ${message}`);
        
        // 广播给所有在线客户端
        wss.clients.forEach((client) => {
            if (client.readyState === ws.OPEN) {
                client.send(`Broadcast: ${message}`);
            }
        });
    });

    ws.on('close', () => {
        console.log('[WS 连接关闭]');
    });
});

// 3. 统一监听端口
server.listen(3000, () => {
    console.log('HTTP & WebSocket Server 正在监听端口 3000');
});

四、 高并发网络架构的生产调优建议

1. Keep-Alive 策略： 针对 HTTP/WebSocket 连接，合理配置闲置超时时间，防止恶意僵尸连接耗尽系统文件描述符（File Descriptors）。
2. 集群化与负载均衡： 单个 Node.js 进程受限于 V8 内存上限（通常为 1.5GB~4GB）以及单线程 CPU 瓶颈。在高并发网络场景下，必须通过内置的 cluster 模块或 PM2 开启 Cluster 模式，利用 SO_REUSEPORT 或主进程分发机制实现多进程负载均衡。
3. 系统内核参数调优（Linux）：

• 增大最大文件打开数：ulimit -n 65535
• 调整 TCP 缓冲区和套接字队列大小（修改 /etc/sysctl.conf 中的 net.core.somaxconn 等参数）。

五、 总结

通过底层 net / dgram Socket 到上层 WebSocket 的演进，我们可以发现 Node.js 在处理各种量级的网络I/O时都表现得游刃有余。然而，随着并发连接数和吞吐量的飙升，内存管理成为了决定系统稳定性的另一大生死关卡。