一个很常见的困惑:监控显示接口成功率 99.9%,用户却反馈“点了没反应”。开发把日志翻出来,发现失败的那批请求其实返回了 200,只是响应体里是一段 HTML 错误页,前端按 JSON 解析失败,于是静默吞掉了。状态码是对的,内容是不对的,两者都不算错,只是没人检查。
还有一个更常见的困惑是“请求数对不上”。一个页面有几十个资源,服务端日志里的请求数却少一些;或者一次点击在日志里出现两次。原因可能有三条:连接复用了,同一条连接上跑了很多请求,日志按连接记账;发生了重定向,客户端悄悄又发了一次;或者代理缓存直接返回,源站压根没收到。
顺便说清“成功”的两个层次。传输层成功,只表示字节送到了;协议层成功,表示这次请求的处理结果被标成 2 开头;业务成功,要求响应体里的内容和业务语义一致。三层里任何一层失败,用户看到的都是“不好用”,但排查入口完全不同。很多值班记录写“接口正常”,其实只验证了第二层。
HTTP 就是浏览器和服务器之间约定好的一套文本格式。它规定了第一行怎么写、头怎么列、body 怎么界定、状态码代表什么。这套格式看起来简单,但真正决定行为的是头字段和连接管理。这篇就从一条原始连接开始,把请求和响应拆开看。
现象:200 不等于成功,日志也不等于真相
HTTP 的状态码是分段的:1 开头是信息,2 开头是成功,3 开头是重定向,4 开头是客户端错误,5 开头是服务端错误。它表达的是“这次请求在协议层面怎么处理”,不是“业务是否成功”。所以 200 加一段错误 JSON、200 加一个登录页、204 什么都没有,都是合法响应。判断业务成败必须看内容,不能只看状态码。
反过来,4 开头的状态码也不一定是客户端的错。401 可能是令牌过期,403 可能是权限配置,404 可能是路由没匹配上,429 可能是被限流。这些都能修,只是修的地方不同。把 4 开头一律当成“调用方写错了”,会浪费很多时间。
日志对不上则通常是连接复用造成的。HTTP/1.1 默认保持连接,一条 TCP 连接上可以连续发很多个请求,服务端按连接写日志时就会把多个请求合并成一条,或者按请求写但连接标识重复。要精确对齐,得看请求级的标识,比如头里的追踪号,而不是看连接数。
一条 HTTP 报文长什么样
请求报文由四部分组成:请求行、头字段、一个空行、可选的报文体。请求行是“方法 路径 版本”,比如 GET /index.html HTTP/1.1。头字段一行一个,形如“名字: 值”,大小写不敏感。空行是分隔符,之后才是 body。服务端解析时,先读到空行,说明头结束了,剩下的按头里声明的方式处理。
响应报文的结构对称:状态行、头字段、空行、body。状态行是“版本 状态码 原因短语”,比如 HTTP/1.1 200 OK。原因短语只是给人看的,程序只认数字。
方法的语义要分清。GET 用来取资源,应该是安全的、幂等的,重复调用不该产生副作用;HEAD 和 GET 一样,但只返回头,常用来探测资源是否存在、是否更新;POST 通常用来创建或提交,不保证幂等;PUT 是整体替换,幂等;DELETE 删除,幂等;PATCH 局部修改。幂等这一条很重要,它决定了请求失败后能不能放心重试。
头字段可以粗略分成几类:描述内容的(类型、长度、编码)、描述连接的(是否保持、是否关闭)、描述缓存的(缓存控制、校验器)、描述认证的(令牌、Cookie)、描述协商的(接受什么类型、什么语言)。数量很多,但排错时真正高频的只有十来个。
走查:一个页面请求是怎么串起来的
第三步的 Host 头在 HTTP/1.1 里是必填的,因为同一台服务器可能托管很多域名,服务器靠它区分你访问的是哪个站点。少了它,或者写错,常见的结果是拿到默认站点的页面,或者直接 400。用 IP 直连调试时最容易踩这个坑。
第四步有两个字段决定了“怎么读完”。有 Content-Length 时,body 长度是确定的,读够就结束;有 Transfer-Encoding: chunked 时,长度不固定,每个小块前面写块大小,最后用一个零长度块表示结束。两者都有是非法组合,代理遇到这种响应往往直接拒绝,这也是请求走私攻击的入口之一。
第五步的压缩是透明的。响应头写 Content-Encoding: gzip,body 就是压缩后的字节,客户端解压后才拿到原文。所以抓包看到的字节数和页面实际大小可能差好几倍,这不是数据丢了,是压缩在起作用。
第六步解释了为什么一个页面会产生几十个请求。HTML 只是骨架,脚本、样式、字体、图片都要单独请求。连接复用让这些请求不必各自握手,但每个请求仍然有自己的头和状态。
实测:用原始套接字跑一次 keep-alive
不用框架,直接用套接字写一个极小的服务端和客户端,观察同一条连接上连续发三个请求会发生什么。服务端会把收到的请求头打印出来。
import socket, threading
captured = []
def server(sock):
sock.listen(4)
while True:
c, addr = sock.accept()
def handle(conn):
while True:
req = b""
while b"\r\n\r\n" not in req:
chunk = conn.recv(4096)
if not chunk:
conn.close()
return
req += chunk
captured.append(req)
head, _, _ = req.partition(b"\r\n\r\n")
lines = head.decode().split("\r\n")
print("[server] 收到 %s %s" % tuple(lines[0].split(" ")[:2]))
for line in lines[1:]:
k, _, v = line.partition(":")
print("[server] %-16s %s" % (k, v.strip()))
body = "hello from server"
resp = (b"HTTP/1.1 200 OK\r\n"
b"Content-Type: text/plain; charset=utf-8\r\n"
b"Content-Length: " + str(len(body)).encode() + b"\r\n"
b"Connection: keep-alive\r\n\r\n" + body.encode())
conn.sendall(resp)
threading.Thread(target=handle, args=(c,), daemon=True).start()
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(("127.0.0.1", 0))
addr = s.getsockname()
threading.Thread(target=server, args=(s,), daemon=True).start()
print("server on", addr)
cl = socket.create_connection(addr)
cl.sendall(b"GET /a HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nAccept: */*\r\n\r\n" % addr[1])
data = cl.recv(4096)
print("[client] 响应首行:", data.split(b"\r\n")[0].decode())
cl.sendall(b"GET /b HTTP/1.1\r\nHost: 127.0.0.1:%d\r\n\r\n" % addr[1])
data2 = cl.recv(4096)
print("[client] 同一连接第二次:", data2.split(b"\r\n")[0].decode())
print("[client] 本地端口复用 =", cl.getsockname()[1], "长度为", len(data), len(data2))
实际输出:
server on ('127.0.0.1', 60392)
[server] 收到 GET /a
[server] Host 127.0.0.1:60392
[server] Accept */*
[client] 响应首行: HTTP/1.1 200 OK
[server] 收到 GET /b
[server] Host 127.0.0.1:60392
[client] 同一连接第二次: HTTP/1.1 200 OK
[client] 本地端口复用 = 60393 长度为 121 121
两次请求都从同一个本地端口 60393 发出,说明连接没有重建,第二个请求直接接在第一个后面。这就是 keep-alive:省掉了第二次握手,也省掉了 TLS 重建。真实浏览器对同一域名会开若干条这样的长连接,把并发控制在一个合理范围里。
但这套机制有个前提:双方都知道一个响应在哪里结束。如果服务端写错长度,或者客户端按错的方式读,后面的响应就会错位,出现“第二个请求拿到第一个的响应”。这类错位在代理链路上更难查,因为每一段可能都在用自己的方式重新打包。
实测:抓一个真实站点的响应头
用命令行请求本站的首页,只看头不看体。下面两段是真实返回,第一段走 HTTPS,第二段走 HTTP。
HTTP/1.1 200 OK
Server: nginx/1.18.0 (Ubuntu)
Date: Fri, 06 Nov 2026 14:13:05 GMT
Content-Type: text/html
Content-Length: 10427
Last-Modified: Wed, 16 Sep 2026 08:53:55 GMT
Connection: keep-alive
Vary: Accept-Encoding
ETag: "6aaa5923-28bb"
Accept-Ranges: bytes
HTTP/1.1 301 Moved Permanently
Server: nginx/1.18.0 (Ubuntu)
Content-Type: text/html
Content-Length: 178
Connection: keep-alive
Location: https://docs.czgrzx.cn/
第一段里几个字段值得注意。Content-Length 明确说了 10427 字节,客户端读够就结束;Content-Type 只给了类型没给字符集,靠页面里的声明兜底;ETag 是内容指纹,可用于条件请求;Vary 说明同一地址会因为 Accept-Encoding 不同而返回不同内容,缓存必须把这个头纳入考虑。
第二段是走明文 HTTP 的结果:301 永久重定向到 HTTPS,Location 指明了新地址,Content-Length 178 是那段提示页的长度。这个跳转发生在应用层,浏览器收到后要重新建一条 TLS 连接,多一个往返。很多“首屏慢”就慢在这一跳上,解决办法是在服务端直接返回 HTTPS,或者用 HSTS 让浏览器记住以后只走 HTTPS。
再看压缩。把首页正文取下来,用同样的算法压一遍,10427 字节变成 3384 字节,只有原来的 32.5%。这解释了为什么抓包看到的响应体比页面实际内容小很多。注意压缩后的响应头里 Content-Length 消失了,换成了分块编码,因为压缩后的长度要在发送时才知道;ETag 也变成了带 W/ 前缀的弱校验器,表示“语义相同但字节可能不同”。
还有一个和文档说法不一致的实测结果:带上 If-None-Match 再请求同一个地址,期望得到 304,实际返回的仍然是 200 和完整内容。也就是说这台服务器没有按条件请求返回“未修改”,浏览器只能重新下载。原因可能是配置没开启相关模块,也可能中间有缓存层改写了行为,未在本机进一步确认。这个例子的价值在于提醒:协议规定的行为,和眼前这台服务器的行为,是两件事,验证要以实测为准。
最后是耗时分布。同一次请求里,域名解析 15.8 毫秒,建立连接 68.4 毫秒,TLS 握手 126.4 毫秒,首字节 194.4 毫秒,总计 195 毫秒。注意 TLS 那一项是累计值,表示到握手完成为止的总时间,不是单独花了 126 毫秒。看这类数字要先弄清每个字段的起点,否则很容易把累计值当成分段值相加。
缓存、校验器和那些容易被改写的头
缓存分两种。一种是强缓存,靠 Cache-Control 里的最大存活时间,时间没到就直接用本地副本,连请求都不发;另一种是协商缓存,靠 ETag 或 Last-Modified,每次问一下服务器“我这份还能用吗”,服务器回 304 就继续用本地副本。前者省事,后者能保证内容新鲜,代价是多一个往返。
ETag 分强弱。强校验器要求字节完全一致,弱校验器只要求语义一致,带 W/ 前缀。压缩之后字节变了,只能给弱校验器,否则同一个地址在不同编码下会算出不同的强指纹,缓存直接失效。这也是为什么开了压缩的站点,ETag 常常带 W/。
代理会改头。X-Forwarded-For 记录原始客户端地址,X-Forwarded-Proto 记录原始协议,Via 记录经过了哪些代理。应用如果直接信任这些头,就可能被伪造,拿到错误的客户端 IP 或协议。正确做法是只信任自己这层代理加的头,并且明确信任链。
Cookie 也是头的一部分,但它的规则更绕:域、路径、过期时间、是否只能走 HTTPS、是否禁止脚本读取。任何一个属性配错,都会导致“登录状态带不过去”或者“被第三方页面读到”。这部分内容足够单独写一篇,这里只需要记住它挂在请求头上,跟着每次请求走。
Cache-Control 的常见取值值得记住几个:no-store 表示完全不许缓存,no-cache 表示可以存但每次都要验证,max-age 表示可以在一段时间内直接用,s-maxage 专门约束共享缓存,private 表示只允许浏览器自己存。把 no-cache 当成“不缓存”是最常见的误读,它其实是“先问再用”。配错这一个词,可能让全站缓存失效,也可能让敏感数据留在中间代理上。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 状态码 200,但前端解析失败 | 响应体是错误页或登录页,业务并未成功 | 看 Content-Type 和响应体前几十字节 |
| 页面一直转圈,最后超时 | 响应长度声明与实际不符,客户端一直在等剩余字节 | 对比 Content-Length 和实际收到的字节数 |
| 第二个请求拿到第一个的响应 | 长度或分块解析错位,连接上的消息边界乱了 | 检查是否有非法的长度与分块组合 |
| 请求数比页面资源数少 | 连接复用、代理缓存命中或请求被合并 | 看请求级追踪号,不要按连接计数 |
| 带 If-None-Match 仍返回 200 | 服务端未启用条件请求,或校验器不匹配 | 直接比对返回的 ETag 与请求里带的是否一致 |
| 抓包字节数远小于页面大小 | 响应体经过 gzip 等压缩 | 看 Content-Encoding,解压后再比较 |
| 用 IP 访问拿到别人的站点 | 缺少或写错 Host 头,虚拟主机匹配到了默认站点 | 补上正确的 Host 再请求一次 |
| 明文地址总被跳到 HTTPS | 服务端配置了 301,或浏览器受 HSTS 约束 | 看第一跳的 Location 和响应码 |
边界与代价
HTTP/1.1 最大的结构性代价是队头阻塞。同一条连接上,前一个响应没传完,后一个只能等;浏览器只好对同一域名开多条连接来绕,连接一多,握手和内存成本又上来了。HTTP/2 用多路复用把这个问题缓解了,但一条 TCP 连接上的丢包仍会拖慢所有流;HTTP/3 换到 UDP 上,把流单独隔离,才算从机制上解决。
第二个代价是头的重复。每个请求都要带 Host、User-Agent、Accept、Cookie 这一串,页面资源多的时候,头的总字节可能超过正文。HTTP/2 用头部压缩缓解,但压缩本身要维护状态,代理和调试工具处理起来更复杂。
第三个代价是无状态带来的补丁。HTTP 本身不记登录状态,于是有了 Cookie、Session、Token,各自都有安全和过期问题。把状态放在客户端,要考虑防篡改;放在服务端,要考虑多实例共享。没有一种方案是纯赚的。
第四个代价是明文。HTTP 的内容在链路上可读可改,中间人可以插入广告、替换下载包、篡改接口返回。所以现代浏览器把非 HTTPS 的页面标成不安全,很多新接口也只在 HTTPS 下可用。加密本身也有成本,握手要时间,内容要加解密,但这些成本已经被压得很低,不值得为省它去冒风险。
当天能自己验证的练习
- 把上面的套接字示例跑一遍,再把第二个请求的
Connection头改成close,观察服务端是否在响应后关闭连接、客户端第二次发送会怎样。 - 用
curl -sI请求本站首页,把每一个响应头抄下来,标出哪些跟缓存有关、哪些跟连接有关、哪些跟内容有关。 - 用
curl -H "Accept-Encoding: gzip" -sI再请求一次,对比两次返回里 Content-Length、Content-Encoding 和 ETag 的变化。 - 用
curl -w把解析、连接、握手、首字节四个时间打出来,注意 TLS 那一项是累计值,不要重复相加。 - 在浏览器开发者工具里找一个 304 响应,如果找不到,说明本站没有启用条件缓存;再用带 If-None-Match 的请求验证一次,记录真实状态码。本机没有代理抓包环境,中间链路的改写未在本机实测。
小结与下一篇
HTTP 是一套文本格式加一组约定:请求行说做什么,头说怎么理解,body 说具体内容;状态码只描述协议层结果,不替你判断业务成败。连接可以复用,但每个响应必须有明确的结束边界;压缩会改变字节数,条件缓存能省下重复下载,但都要以实测为准。日志里的请求数、抓包里的字节数、页面上看到的内容,三者对不上是常态,关键是知道差在哪一环。
下一篇讲数据包怎么从你家走到机房:交换、路由与 NAT。请求发出之后,它并不会“直达”服务器,中间要经过交换机、路由器、运营商和一堆你不认识的设备。看清这段路,才能理解为什么同一个请求在不同网络下表现完全不同。