Reactor 在 WebServer 与 WebSocket 中的应用

Sun, 09 Aug 2026 00:00:00 +0800

本篇是《网络IO》《IO 多路复用与 Reactor》《Reactor 与 epoll：百万并发网络服务器》的后续实践。
socket、fd、select、poll、epoll 接口、连接对象和 Reactor 基础不再重复；本篇只整理这节课新增的 LT/ET、HTTP WebServer、文件发送状态机和 WebSocket。

一、本节课做了什么

前一节已经搭好了 Reactor 网络层，本节在它上面接入两种协议业务：

reactor.c：网络 I/O 层
 ├── recv_cb()
 └── send_cb()

webserver.c：HTTP 协议层
 ├── http_request()
 └── http_response()

websocket.c：WebSocket 协议层
 ├── ws_request()
 └── ws_response()

本节最重要的调用链：

clientfd 出现 EPOLLIN
 ↓
recv_cb() 调用 recv()
 ↓
http_request() / ws_request()
 ↓
set_event(fd, EPOLLOUT, 0)
 ↓
clientfd 出现 EPOLLOUT
 ↓
send_cb()
 ↓
http_response() / ws_response()
 ↓
send()
 ↓
set_event(fd, EPOLLIN, 0)

因此，Reactor 与协议层的分工是：

reactor.c → 关心 fd 是否可读、可写，以及 recv/send
webserver.c → 关心 HTTP 请求和 HTTP 响应
websocket.c → 关心握手、帧解码和帧编码

二、LT 与 ET

2.1 LT：水平触发

只要内核接收缓冲区中还有数据，LT 就会继续报告可读事件。

例如客户端发送 32 字节，服务端一次只接收 10 字节：

第一次 recv：10 字节，剩余 22
第二次 recv：10 字节，剩余 12
第三次 recv：10 字节，剩余 2
第四次 recv：2 字节，接收完成

2.2 ET：边沿触发

ET 主要关注从“没有数据”到“有数据”的状态变化。收到一次通知后，应在当前回调中尽量把数据处理完。

当前代码在 accept_cb() 中这样注册客户端：

event_rigister(clientfd,EPOLLIN|EPOLLET);//|EPOLLET

这表示 clientfd 使用 ET，并且先关注可读事件。

ET 的处理思路：

accept_cb() → 持续 accept，直到当前没有新连接
recv_cb() → 持续 recv，直到当前数据读完
send_cb() → 持续推进发送，直到发完或暂时不可写

循环读取时要配合非阻塞 fd。当前没有更多数据时，recv() 返回 -1，并且 errno 为 EAGAIN 或 EWOULDBLOCK，这表示本轮读取结束，应回到事件循环。

LT 和 ET 都不能决定 HTTP 请求或 WebSocket 帧是否完整。TCP 是字节流，协议层仍然需要根据协议格式判断消息边界。

三、`recv_cb()`：从网络层进入协议层

本节使用你提交的原代码：

int recv_cb(int fd){
 memset(conn_list[fd].rbuffer,0,BUFFER_LENGTH);
	int count = recv(fd, conn_list[fd].rbuffer, BUFFER_LENGTH, 0);
	if (count == 0) { // disconnect
		printf("client disconnect: %d\n", fd);
		close(fd);

 epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);//unfinished

		return -1;

				}else if(count<0){
 printf("count:%d,errno:%d ,%s\n", count,errno,strerror(errno));
		 close(fd);
 epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);//unfinished
 return 0;
 }
 conn_list[fd].rlength=count;
 // printf("RECV: %s\n", conn_list[fd].rbuffer);
#if 0//echo
 conn_list[fd].wlength=conn_list[fd].rlength;
 memcpy(conn_list[fd].wbuffer,conn_list[fd].rbuffer,conn_list[fd].wlength);
 printf("[%d]RECV: %s\n",conn_list[fd].rlength,conn_list[fd].rbuffer);
#elif0
 http_request(&conn_list[fd]);
#else 
 ws_request(&conn_list[fd]);
#endif

 set_event(fd,EPOLLOUT,0);
 return count;
}

3.1 接收数据

int count = recv(fd, conn_list[fd].rbuffer, BUFFER_LENGTH, 0);

数据从内核 socket 接收缓冲区复制到当前连接的 rbuffer，实际接收长度保存到：

conn_list[fd].rlength=count;

3.2 三种业务切换

Echo 分支把收到的数据复制到写缓冲区：

#if 0//echo
 conn_list[fd].wlength=conn_list[fd].rlength;
 memcpy(conn_list[fd].wbuffer,conn_list[fd].rbuffer,conn_list[fd].wlength);
 printf("[%d]RECV: %s\n",conn_list[fd].rlength,conn_list[fd].rbuffer);

HTTP 分支把连接对象交给 `http_request()`：

```c
#elif0
 http_request(&conn_list[fd]);
```

WebSocket 分支把连接对象交给 `ws_request()`：

```c
#else 
 ws_request(&conn_list[fd]);
```

三种业务共用同一个 `recv_cb()`，只替换上层协议处理函数。这正是 Reactor 与业务分层后的好处。

3.3 从读事件切换到写事件

set_event(fd,EPOLLOUT,0);

http_request() 或 ws_request() 处理完输入后，当前 fd 改为关注 EPOLLOUT。等 socket 可写时，Reactor 会调用 send_cb()。

四、HTTP 请求：`http_request()`

浏览器访问服务器时，会发送类似内容：

GET / HTTP/1.1
Host: 172.16.145.129:2000
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)
Accept: text/html,application/xhtml+xml,application/xml
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8

请求由请求行、请求头、空行和可选 body 组成：

GET / HTTP/1.1 → 请求行
Host → 请求头
Connection → 请求头
User-Agent → 请求头
空行 → 请求头结束

原代码：

int http_request(struct conn *c){
 //printf("request: %s\n",c->rbuffer);
 memset(c->wbuffer,0,BUFFER_LENGTH);
 c->wlength=0;
 c->status=0;
}

当前 http_request() 主要完成一次新响应的状态初始化：

c->rbuffer → 当前 HTTP 请求
c->wbuffer → 清空，准备写响应
c->wlength → 置 0
c->status → 置 0，从响应状态机起点开始

它位于：

recv_cb() 之后
send_cb() 之前

五、HTTP 响应：直接返回 HTML

原代码：

int http_response(struct conn *c){
#if 1
 c->wlength=sprintf(c->wbuffer,"HTTP/1.1 200 OK\r\n"
 "Content-Type: text/html\r\n"
 "Accept-Ranges: bytes\r\n"
 "Content-Length: 82\r\n"
 "Date: Tue,30 Apr 2024 13:16:46 GMT\r\n\r\n"
 "<html><head><title>0voice.king</title></head><body><h1>King</h1></body></html>\r\n\r\n");
 return 0;

其中：

HTTP/1.1 200 OK
Content-Type: text/html
Accept-Ranges: bytes
Content-Length: 82
Date: Tue,30 Apr 2024 13:16:46 GMT

是 HTTP 状态行和响应头。它们告诉浏览器响应是否成功、body 是什么类型、长度是多少。

下面是 HTTP body：

<html><head><title>0voice.king</title></head><body><h1>King</h1></body></html>

浏览器看到 Content-Type: text/html 后，会把 body 当作 HTML 渲染，页面中显示 King。

这一分支中，HTTP 头和 body 一起写入：

c->wbuffer

总长度由 sprintf() 的返回值保存到：

c->wlength

调用链：

recv_cb()
 ↓
http_request()
 ↓
设置 EPOLLOUT
 ↓
send_cb()
 ↓
http_response()
 ↓
HTTP 头和 HTML 写入 wbuffer
 ↓
send()

六、返回 `index.html`

原代码：

#elif 0
 int filefd =open("index.html",O_RDONLY);
 struct stat stat_buf;
 fstat(filefd,&stat_buf);
 c->wlength=sprintf(c->wbuffer,"HTTP/1.1 200 OK\r\n"
 "Content-Type: text/html\r\n"
 "Accept-Ranges: bytes\r\n"
 "Content-Length: %ld\r\n"
 "Date: Tue,30 Apr 2024 13:16:46 GMT\r\n\r\n",
 stat_buf.st_size);

 int count=read(filefd,c->wbuffer+c->wlength,BUFFER_LENGTH-c->wlength);
 c->wlength +=count;

 close(filefd);

执行过程：

open("index.html")
 ↓
fstat() 得到文件大小
 ↓
HTTP 响应头写入 wbuffer
 ↓
read() 把 index.html 追加在 HTTP 头后面
 ↓
wlength = HTTP 头长度 + 本次文件读取长度
 ↓
send_cb() 发送整个 wbuffer

stat_buf.st_size 被写入：

Content-Length: 文件大小

这个分支的特点是：HTTP 头和文件内容都先进入应用层 wbuffer，然后统一调用 send()。

七、状态机与 `sendfile()`

当一个响应需要多个发送阶段时，课程使用 status 保存当前进度：

status = 0 → 构造并发送 HTTP 头
status = 1 → 持续发送文件
status = 2 → 文件发送结束，清理状态

原代码：

#elif 0
 int filefd =open("index.html",O_RDONLY);
 struct stat stat_buf;
 fstat(filefd,&stat_buf);
 if(c->status==0){
 c->wlength=sprintf(c->wbuffer,"HTTP/1.1 200 OK\r\n"
 "Content-Type: text/html\r\n"
 "Accept-Ranges: bytes\r\n"
 "Content-Length: %ld\r\n"
 "Date: Tue,30 Apr 2024 13:16:46 GMT\r\n\r\n",
 stat_buf.st_size);
 c->status=1;
 }else if (c->status==1){
 int ret=sendfile(c->fd,filefd,NULL,stat_buf.st_size);
 if(ret==-1){
 printf("error:%d\n",errno);
 }
 //c->wlength=0;
 memset(c->wbuffer,0,BUFFER_LENGTH);
 c->status=2;
 }else if(c->status==2){

 c->wlength=0;
 memset(c->wbuffer,0,BUFFER_LENGTH);
 c->status=0;
 }
 close(filefd);

状态流转：

第一次进入 http_response()
 ↓ status == 0
构造 HTTP 响应头
 ↓ status = 1
send_cb() 发送 wbuffer，并继续关注 EPOLLOUT
 ↓
第二次进入 http_response()
 ↓ status == 1
sendfile() 发送 index.html
 ↓ status = 2
继续关注 EPOLLOUT
 ↓
第三次进入 http_response()
 ↓ status == 2
清理 wbuffer 和 wlength
 ↓ status = 0
重新关注 EPOLLIN

sendfile() 直接建立文件 fd 到 socket fd 的发送路径：

int ret=sendfile(c->fd,filefd,NULL,stat_buf.st_size);

协议层仍然负责构造 HTTP 头，sendfile() 负责发送文件内容。状态机把两个阶段连接起来。

八、返回图片

图片与 HTML 在网络层都是字节数据，主要区别是 HTTP 的 Content-Type。

原代码：

#else
int filefd =open("vip.png",O_RDONLY);
 struct stat stat_buf;
 fstat(filefd,&stat_buf);
 if(c->status==0){
 c->wlength=sprintf(c->wbuffer,"HTTP/1.1 200 OK\r\n"
 "Content-Type: image/png\r\n"
 "Accept-Ranges: bytes\r\n"
 "Content-Length: %ld\r\n"
 "Date: Tue,30 Apr 2024 13:16:46 GMT\r\n\r\n",
 stat_buf.st_size);
 c->status=1;
 }else if (c->status==1){
 int ret=sendfile(c->fd,filefd,NULL,stat_buf.st_size);
 if(ret==-1){
 printf("error:%d\n",errno);
 }
 //c->wlength=0;
 memset(c->wbuffer,0,BUFFER_LENGTH);
 c->status=2;
 }else if(c->status==2){

 c->wlength=0;
 memset(c->wbuffer,0,BUFFER_LENGTH);
 c->status=0;
 }
 close(filefd);

与 HTML 文件的区别：

响应内容	打开的文件	Content-Type
网页	`index.html`	`text/html`
PNG 图片	`vip.png`	`image/png`

Reactor 的 recv_cb()、send_cb() 不需要知道 body 是网页还是图片。WebServer 协议层设置正确的响应头即可。

九、`send_cb()` 如何驱动多阶段发送

原代码：

int send_cb(int fd){
#if 0

 http_response(&conn_list[fd]);

#else
 ws_response(&conn_list[fd]);

#endif
 int count=0;
 if(conn_list[fd].status==1){
 //printf("SEND:%s\n",conn_list[fd].wbuffer);
 count = send(fd, conn_list[fd].wbuffer,conn_list[fd].wlength, 0);
 set_event(fd,EPOLLOUT,0);
}else if(conn_list[fd].status==2){
 set_event(fd,EPOLLOUT,0);
}else if(conn_list[fd].status==0){
 if(conn_list[fd].wlength !=0){
 count = send(fd, conn_list[fd].wbuffer,conn_list[fd].wlength, 0); 
 }
 set_event(fd,EPOLLIN,0);
}
 //set_event(fd,EPOLLOUT,0);
 return count;
}

9.1 选择协议响应

学习 HTTP 时，让写回调进入：

#if 0

 http_response(&conn_list[fd]);

学习 WebSocket 时，让写回调进入：

#else
 ws_response(&conn_list[fd]);

9.2 状态与事件切换

status == 1
 → send() 发送当前 wbuffer
 → 继续设置 EPOLLOUT
 → 等待下一阶段

status == 2
 → 继续设置 EPOLLOUT
 → 进入状态机清理阶段

status == 0
 → 如果 wlength 不为 0，就发送当前数据
 → 设置 EPOLLIN
 → 等待下一次请求

这就是“需要发送多次时怎么办”的答案：

保存当前发送状态，再通过后续的 EPOLLOUT 事件继续推进，而不是把整个过程强行塞进一次回调。

十、WebSocket 握手

WebSocket 用于浏览器与服务器之间的长连接和双向通信。

建立 WebSocket 连接时，浏览器先发送 HTTP Upgrade 请求，其中包括：

Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: T29c4Rys861qGqbGGNdkwA==
Sec-WebSocket-Version: 13

你提交的 WebSocket 代码：

#include"server.h"
#include<stdio.h>
#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
/*
Key："T29c4Rys861qGqbGGNdkwA=="
T29c4Rys861qGqbGGNdkwA==258EAFA5-E914-47DA-95CA-C5AB0DC85B11
SHA-1

20 bytes
base64

handshake

transmission
decode
encode

*/

服务端计算 Sec-WebSocket-Accept 的过程：

客户端 Sec-WebSocket-Key
 +
固定 GUID
 ↓
SHA-1
 ↓
160 bit = 20 bytes
 ↓
Base64
 ↓
Sec-WebSocket-Accept

固定 GUID：

#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

客户端 Key 放在前面，GUID 放在后面。

服务端响应格式：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: 计算结果

返回 101 后，同一个 TCP 连接不再传输普通 HTTP 消息，而是进入 WebSocket 帧传输阶段。

十一、WebSocket 在 Reactor 中的位置

原代码：

int ws_request(struct conn *c){
 printf("request: %s",c->rbuffer);
}

int ws_response(struct conn *c){
 
}

当前两个函数是课程为后续实现预留的协议接口。

ws_request() 后续负责：

握手阶段 → 解析 HTTP Upgrade 请求和 Sec-WebSocket-Key
传输阶段 → 解析 WebSocket frame，完成 decode

ws_response() 后续负责：

握手阶段 → 构造 101 和 Sec-WebSocket-Accept
传输阶段 → 把文本或二进制业务数据 encode 成 WebSocket frame

在 Reactor 中的调用位置：

EPOLLIN
 ↓
recv_cb()
 ↓
ws_request()
 ↓
设置 EPOLLOUT
 ↓
send_cb()
 ↓
ws_response()
 ↓
send()

WebSocket 是应用层协议，底层仍然是普通 TCP clientfd。Reactor 不需要为 WebSocket 创建一种新 fd。

十二、使用 wrk 测试 WebServer

测试命令：

wrk -t10 -c50 -d10s http://172.16.145.129:2000/

课程中的测试现象：

打印每次 request 和 Host 数据时：QPS 约 1.5 万
关闭逐请求打印后：QPS 约 4.5 万

逐请求打印会产生格式化、终端输出和系统调用开销，因此会明显降低服务器吞吐量。

wrk 结果中主要关注：

Requests/sec → 每秒请求数，即 QPS
Latency → 请求延迟
timeout → 超时数量
read/write → 读写错误
Transfer/sec → 每秒传输数据量

局域网延迟较小；公网还会受到网络时延、丢包、带宽和中间设备影响。

十三、Connection reset by peer

Connection reset by peer 表示连接被对端通过 TCP RST 重置。

常见情况：

客户端提前关闭连接
压测工具结束请求
服务器准备发送时客户端已经退出
网络设备重置连接

服务器应识别错误并清理当前连接，不要让单个客户端断开导致整个进程退出。

十四、本节课的三个重点

重点一：事件与协议函数的对应关系

clientfd + EPOLLIN
 → recv_cb()
 → http_request() / ws_request()

clientfd + EPOLLOUT
 → send_cb()
 → http_response() / ws_response()

重点二：网络层与协议层分离

reactor.c
 → 管理 fd、事件、recv、send

webserver.c
 → 处理 HTTP request 和 response

websocket.c
 → 处理 handshake、decode 和 encode

重点三：多次发送使用状态机

一次发送即可完成
 → wbuffer + wlength

需要多个发送阶段
 → status 保存进度
 → 多次 EPOLLOUT 推进

发送静态文件
 → HTTP 头放入 wbuffer
 → 文件内容交给 sendfile()

最终理解：

Reactor 提供统一的事件驱动网络层；HTTP 和 WebSocket 负责协议，业务数据何时读取、何时发送，由 fd 的事件和回调共同驱动。

WebSocket on JasperSao的博客

Reactor 在 WebServer 与 WebSocket 中的应用

一、本节课做了什么

二、LT 与 ET

2.1 LT：水平触发

2.2 ET：边沿触发

三、recv_cb()：从网络层进入协议层

3.1 接收数据

3.2 三种业务切换

3.3 从读事件切换到写事件

四、HTTP 请求：http_request()

五、HTTP 响应：直接返回 HTML

六、返回 index.html

七、状态机与 sendfile()

八、返回图片

九、send_cb() 如何驱动多阶段发送

9.1 选择协议响应

9.2 状态与事件切换

十、WebSocket 握手

十一、WebSocket 在 Reactor 中的位置

十二、使用 wrk 测试 WebServer

十三、Connection reset by peer

十四、本节课的三个重点

重点一：事件与协议函数的对应关系

重点二：网络层与协议层分离

重点三：多次发送使用状态机

三、`recv_cb()`：从网络层进入协议层

四、HTTP 请求：`http_request()`

六、返回 `index.html`

七、状态机与 `sendfile()`

九、`send_cb()` 如何驱动多阶段发送