04.7.20.1 HTTP 客户端与序列化库
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.20 Python 常用第三方库
覆盖范围
- requests:
Session会话复用、HTTPAdapter连接池参数、默认无超时危害、stream=True流式下载、SSL 校验与urllib3.Retry重试策略 - httpx:同步/异步双 API、
AsyncClient与Limits、HTTP/2、超时对象分级 - aiohttp:
ClientSession连接复用、TCPConnector并发上限与事件循环绑定 - 序列化:orjson/ujson/msgspec 性能与兼容差异、
pickle反序列化安全边界 - 编码、压缩、文件上传与大响应流式处理
04.7.20.1-001 requests 为什么默认不设置超时?
一句话结论
requests 2.32 系列在调用 requests.get/post/... 时不传 timeout 参数,底层 socket 就没有超时上限,连接或读取可以一直阻塞到对端断开或进程被外部杀掉。这是历史 API 设计遗留:库本身不替业务决定等待多久,因此把超时责任留给调用方。
概念解释
timeout同时控制连接阶段与读取阶段,单位秒,可以传浮点数。- 超时不是“总耗时上限”,而是两次等待之间的间隔上限:连接一次握手等待、每次读数据等待。
- 生产代码里“忘了传 timeout”是最常见的线上事故来源之一。
原理流程
- 调用方发起请求,未传
timeout。 - requests 把
None透传给 urllib3 的连接与读取逻辑。 - 底层 socket 以阻塞模式等待,没有
SO_RCVTIMEO/SO_SNDTIMEO超时。 - 对端不响应时,调用线程/协程一直挂起,直到 TCP 层超时或进程退出。
代码或图示
import requests
# 危险:对端挂起时线程永久阻塞
resp = requests.get("https://example.com/api")
# 安全:连接 3 秒、读取 10 秒
resp = requests.get("https://example.com/api", timeout=(3, 10))
常见误区
- 以为“内网调用不会超时”:网络分区、下游 GC、连接挂死都可能让请求长期无响应。
- 把
timeout理解成整个请求的最大耗时:它只约束单次连接等待与单次读取等待,慢响应分多次返回时总耗时可以更长。 - 全局默认超时需要自己封装客户端,requests 不会在
Session上提供一个“默认 timeout”参数。
追问
- 不传 timeout 会发生什么?答:socket 阻塞等待,直到对端断开、TCP 超时或进程被杀。
- timeout 是总耗时吗?答:不是,它分 connect 与 read 两段,约束的是单次等待间隔。
- 如何给所有请求统一加超时?答:封装一层请求方法,或在
HTTPAdapter/会话包装里强制注入默认值。
04.7.20.1-002 不设超时会造成什么连锁后果?
一句话结论
下游变慢时,阻塞的工作线程/协程无法释放,请求在入口处堆积,内存与文件描述符持续增长,最终拖垮整个服务;这是典型的“级联故障”起点,而不是单个慢请求问题。
概念解释
- 同步服务(gunicorn + 线程/进程):每个阻塞请求占一个 worker 或线程,占满后新请求排队或拒绝。
- 异步服务:如果用同步 requests 跑在事件循环里,阻塞会卡住整个 loop;即便用异步客户端,无超时的协程也会持续占用内存。
- 故障扩散路径:下游慢 → 本服务线程堆积 → 入口队列满 → 健康检查失败 → 被摘除或重启。
原理流程
- 下游响应变慢,本服务调用线程挂起等待。
- 新请求不断进入,每个都新开线程等待,线程数与内存上涨。
- 连接池、文件描述符、内存达到上限,开始抛异常。
- 入口层超时或拒绝新请求,故障从一个下游扩散到本服务。
代码或图示
下游变慢 → 线程/协程堆积 → 内存与 fd 上涨 → 入口队列满 → 健康检查失败 → 服务被摘除
常见误区
- 只加“请求入口超时”不够:出口调用不超时,入口线程照样被占住。
- 以为重试能缓解:下游已经慢时重试只会放大流量,必须配合超时、限流与熔断。
- 忽略文件描述符:每个挂起连接占用一个 fd,耗尽后新连接直接失败。
追问
- 无超时最先耗尽什么资源?答:工作线程/协程,随后是内存、fd 与连接池。
- 为什么重试会放大故障?答:同一慢下游被重复请求,流量成倍增加。
- 同步库放进异步 loop 有什么额外风险?答:阻塞调用卡住事件循环,所有并发请求一起停顿。
04.7.20.1-003 Session 如何复用连接与 Cookie?
一句话结论
requests.Session 在内部持有 urllib3 连接池,同一主机的多次请求复用 keep-alive 连接,并自动维护 Cookie Jar;跨请求的认证头、默认参数也挂在 Session 上,避免每次请求重复握手与重复携带凭证。
概念解释
- 连接复用:TCP 三次握手与 TLS 握手只在首次发生,后续请求走已建立的 keep-alive 连接。
- Cookie 持久化:
Session.cookies是RequestsCookieJar,响应里的Set-Cookie自动写回,下次请求自动带上。 - 进程内长期复用 Session 时,要注意线程安全与连接池大小。
原理流程
- 创建
Session(),初始化 Cookie Jar 与挂载的HTTPAdapter。 - 首次请求经 adapter 从连接池取/建连接,完成握手。
- 响应 Cookie 写入 Jar,连接归还池中保持 keep-alive。
- 后续请求命中同一连接,复用 TCP/TLS 通道并自动携带 Cookie。
代码或图示
import requests
s = requests.Session()
s.headers.update({"User-Agent": "my-client/1.0"})
r1 = s.get("https://example.com/login")
r2 = s.get("https://example.com/profile") # 复用连接与 Cookie
常见误区
- 把 Session 当成“全局单例到处传”:长生命周期 Session 会持有连接与 Cookie,需评估隔离性。
- 以为 Session 复用的是登录态:Cookie 由服务端下发,Session 只是携带,过期后需要重新登录。
- 忘记关闭 Session:连接池中 keep-alive 连接需要在生命周期结束时释放,短脚本可
with requests.Session() as s:。
追问
- Session 复用的底层是什么?答:urllib3 连接池里的 keep-alive 连接。
- Cookie 存放在哪里?答:
Session.cookies,一个RequestsCookieJar。 - 多个不同账号能用同一个 Session 吗?答:不建议,Cookie 与头会串,应按会话隔离。
04.7.20.1-004 HTTPAdapter 与连接池参数怎么调?
一句话结论
HTTPAdapter 通过 pool_connections(保持复用的连接数)、pool_maxsize(每主机最大连接数)、pool_block(池耗尽时是否阻塞等待)控制连接池行为;并发量上来后默认 pool_maxsize=10 容易成为瓶颈。
概念解释
pool_connections:池中保活的连接主机数,空闲连接保留多少条。pool_maxsize:同一个主机最多建立多少条并发连接。pool_block=False(默认):池满时直接新建连接;True:阻塞等待归还。- 适配器按 scheme 挂载:
session.mount("https://", HTTPAdapter(...))。
原理流程
- 创建
HTTPAdapter并配置池参数。 - 调用
session.mount把适配器绑定到 http/https 前缀。 - 请求经过适配器,urllib3 按池参数取连接、复用或新建。
- 响应结束后连接归还池,按 keep-alive 策略保留或关闭。
代码或图示
import requests
from requests.adapters import HTTPAdapter
adapter = HTTPAdapter(pool_connections=20, pool_maxsize=50, pool_block=False)
s = requests.Session()
s.mount("https://", adapter)
s.mount("http://", adapter)
常见误区
- 只调
pool_maxsize不评估下游承载:连接开得过大反而压垮对端。 - 混淆
pool_connections与pool_maxsize:前者是空闲保活数量,后者是并发上限。 - 多线程共用 Session 时池参数要按总并发设计,而不是按单线程。
追问
- 默认 pool_maxsize 是多少?答:10(待确认:验证点:查看 requests.adapters.HTTPAdapter 源码默认参数)。
- pool_block=True 有什么代价?答:池满时调用方阻塞等待归还,可能把超时拖长。
- 连接池大小与下游连接数什么关系?答:本服务池上限不能让下游总连接数超过其容量。
04.7.20.1-005 urllib3.Retry 策略由哪些参数组成?
一句话结论
urllib3.util.Retry 用 total/connect/read 限制重试次数,backoff_factor 控制退避间隔,status_forcelist 指定触发重试的状态码,allowed_methods 指定哪些方法可重试,backoff_max 限制退避上限。
概念解释
- 退避公式:
backoff_factor * (2 ** (retries - 1)),指数增长,再叠加可选抖动。 - 默认
allowed_methods不含 POST:POST 被视为非幂等,不自动重试(待确认:验证点:urllib3 版本中默认方法集合)。 status_forcelist常见填 429、500、502、503、504;400/401/403/404 不应重试。
原理流程
- 配置
Retry实例,写清次数、退避、状态码、方法白名单。 - 把 Retry 挂到
HTTPAdapter.max_retries。 - 一次请求失败后,urllib3 判断是否命中可重试条件。
- 命中则按退避间隔等待后重试,超出
total或不可重试则抛出异常。
代码或图示
from urllib3.util.retry import Retry
retry = Retry(
total=3,
backoff_factor=0.5,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["GET", "HEAD", "OPTIONS"],
backoff_max=30,
)
常见误区
- 对所有方法开重试:POST/PATCH 可能造成重复下单、重复扣款。
- 只看状态码不看异常:连接错误、读超时是否重试也要在策略里区分。
- 退避没有上限:故障持续时重试间隔无限增长,应设
backoff_max。
追问
- 退避间隔怎么算?答:
backoff_factor * 2**(重试次数-1),指数增长。 - 哪些状态码不该重试?答:400/401/403/404 这类确定性失败。
- 为什么默认不重试 POST?答:POST 通常非幂等,重试可能产生重复副作用。
04.7.20.1-006 如何在 requests 中挂载重试?
一句话结论
requests 本身不直接暴露重试配置,需要构造 HTTPAdapter(max_retries=Retry(...)) 并 mount 到 Session;重试在 adapter 层完成,业务代码无需手写循环。
概念解释
- 重试发生在 urllib3 连接层,覆盖连接失败与指定状态码。
- 业务层还可以在上面再包一层重试(如 tenacity),两层职责不同:底层处理瞬时网络抖动,业务层处理需要判断响应体的场景。
- 必须配合超时,否则重试间隔内每次等待都可能无限阻塞。
原理流程
- 构造
Retry策略实例。 - 用它创建
HTTPAdapter,传入max_retries。 session.mount挂载适配器到 http/https。- 后续请求经 adapter 自动重试,业务代码只处理最终失败。
代码或图示
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
s = requests.Session()
retry = Retry(total=3, backoff_factor=0.5, status_forcelist=[502, 503, 504])
adapter = HTTPAdapter(max_retries=retry)
s.mount("https://", adapter)
resp = s.get("https://example.com", timeout=(3, 10))
常见误区
- 直接在
requests.get上传max_retries:顶层 API 不接受该参数,必须走 Session + adapter。 - 重试不区分异常类型:把参数错误也重试一遍,徒增延迟。
- 忘记设超时:重试叠加无超时等待,故障时阻塞更久。
追问
- 重试挂在哪一层?答:
HTTPAdapter.max_retries,底层由 urllib3 执行。 - 业务层重试和底层重试有什么区别?答:底层管网络抖动与状态码,业务层按响应体与业务错误码判断。
- 重试为什么必须配超时?答:避免每次尝试都无限阻塞,放大故障。
04.7.20.1-007 SSL 校验是怎么做的,何时关闭?
一句话结论
requests 默认校验服务端证书链与主机名:通过系统/ca 包信任链验证证书是否由可信 CA 签发、是否过期、域名是否匹配;verify=False 会跳过校验,仅用于本地调试,生产环境不应关闭。
概念解释
verify=True(默认):校验证书链、有效期、主机名;可传本地 CA 证书路径。verify=False:跳过校验,同时 urllib3 会抛出 InsecureRequestWarning。- 主机名不匹配、证书过期、自签名证书都会触发 SSL 相关异常。
原理流程
- TLS 握手阶段服务端下发证书链。
- 客户端用信任根证书逐级验签,检查有效期与用途。
- 校验证书主题/SAN 与请求主机名是否一致。
- 任一环节失败抛出
SSLError;verify=False则跳过上述检查。
代码或图示
import requests
# 使用自定义 CA 证书
r = requests.get("https://internal.example.com", verify="/etc/ssl/internal-ca.pem")
# 仅本地调试用,生产禁止
r = requests.get("https://example.com", verify=False)
常见误区
- 生产环境图省事
verify=False:中间人可以替换证书窃听或篡改流量。 - 自签名环境只关校验,不加内部 CA:正确做法是把内部根证书加入信任链。
- 以为关了校验就没有警告:urllib3 会持续告警,需显式过滤而非依赖默认静默。
追问
- verify 可以传什么值?答:
True/False或本地 CA 证书/证书包路径。 - 跳过校验有什么风险?答:无法识别中间人,流量可被窃听篡改。
- 内网自签名服务怎么安全接入?答:导入内部根 CA,保留
verify=True。
04.7.20.1-008 stream=True 解决什么问题,不关闭会泄漏什么?
一句话结论
stream=True 让响应体不在请求时一次性读入内存,而是按需迭代读取;适合下载大文件或转发流式响应。用完必须关闭连接(或用 with 上下文),否则连接无法归还连接池,造成连接与文件描述符泄漏。
概念解释
- 默认
stream=False:响应体立即下载到内存,大文件直接撑爆内存。 stream=True:响应头先返回,body 保持连接打开,用iter_content/iter_lines逐块取。- 未关闭的响应会占用底层连接,池内可用连接逐步减少。
原理流程
- 请求带
stream=True,客户端只接收响应头。 - 调用方按块迭代 body,写入文件或转发。
- body 读完后连接自动可归还;中途放弃则需显式
response.close()。 with requests.get(..., stream=True) as r:在退出时保证关闭。
代码或图示
import requests
with requests.get("https://example.com/big.iso", stream=True, timeout=(3, 30)) as r:
r.raise_for_status()
with open("big.iso", "wb") as f:
for chunk in r.iter_content(chunk_size=1024 * 1024):
f.write(chunk)
常见误区
- 流式下载还把整个响应
r.content读出来:内存占用回到默认模式。 - 异常分支忘记关闭:连接泄漏在长服务里累积,最终池耗尽。
iter_content不设 chunk_size:块大小由底层决定,内存不可控。
追问
- stream=True 什么时候返回 body?答:不自动下载,迭代时才从连接读取。
- 不关闭响应泄漏什么?答:底层连接与文件描述符,连接池无法复用。
- 如何保证异常时也关闭?答:用
with包裹响应对象,退出时自动 close。
04.7.20.1-009 大响应下载怎么控制内存与断点续传?
一句话结论
大文件用 stream=True 加 iter_content 分块落盘,按块写入避免整文件进内存;需要断点续传时通过 Range 头带上已下载字节数,服务端支持则返回 206 Partial Content,追加写入本地文件。
概念解释
iter_content(chunk_size):按固定字节块迭代,二进制下载首选;iter_lines面向文本行。Range: bytes=start-:请求从指定偏移开始的剩余内容。- 服务端返回
Accept-Ranges: bytes才支持续传;不支持则需从头重下。
原理流程
- 发起流式请求,先看响应头是否支持 Range。
- 读取本地已下载大小,构造
Range头。 - 收到 206 后以追加模式写入;200 则重新整段下载。
- 循环分块写入直到结束,记录校验摘要用于完整性核对。
代码或图示
import os, requests
local = "big.iso"
pos = os.path.getsize(local) if os.path.exists(local) else 0
headers = {"Range": f"bytes={pos}-"}
with requests.get("https://example.com/big.iso", stream=True, headers=headers, timeout=(3, 30)) as r:
mode = "ab" if r.status_code == 206 else "wb"
with open(local, mode) as f:
for chunk in r.iter_content(1024 * 1024):
f.write(chunk)
常见误区
- 服务端不支持 Range 仍追加写入:会把两段数据接错,必须按状态码决定模式。
- 下载完不校验摘要:静默损坏无法发现。
- 多线程分片下载不记录分片进度:中断后难以对齐续传位置。
追问
- 怎么判断服务端支持续传?答:响应头
Accept-Ranges: bytes。 - 206 与 200 在续传里分别怎么处理?答:206 追加,200 从头覆盖。
- 分块下载用什么迭代器?答:二进制用
iter_content,文本按行用iter_lines。
04.7.20.1-010 文件上传 multipart 怎么构造?
一句话结论
上传文件用 files= 参数传入文件对象或元组,requests 自动构造 multipart/form-data 编码并设置边界;同时提交表单字段用 data=,大文件同样可以流式传入避免整体读入内存。
概念解释
files={"field": open("a.pdf", "rb")}:字段名 + 文件对象,文件名与 Content-Type 由请求自动推断。- 元组形式
(filename, fileobj, content_type)可以显式指定文件名与类型。 - 二进制大对象也可用
data=直接发送字节流,Content-Type 由调用方控制。
原理流程
- 打开待上传文件,以二进制句柄传入
files。 - requests 生成随机边界,按 multipart 规范拼装各部分。
- 表单字段写入对应 section,文件流逐块编码进请求体。
- 服务端按 boundary 拆分字段与文件。
代码或图示
import requests
with open("report.pdf", "rb") as f:
r = requests.post(
"https://example.com/upload",
data={"category": "report"},
files={"file": ("report.pdf", f, "application/pdf")},
timeout=(3, 30),
)
常见误区
- 用文本模式
open(..., "r")上传二进制:内容被编码破坏。 - 文件句柄在请求结束后才关闭:应在
with内完成请求。 - 把整个文件读成字节串再传:大文件不必要地占用内存,流式句柄更优。
追问
- multipart 边界由谁生成?答:requests 生成随机 boundary,写进 Content-Type。
- 表单字段和文件分别用哪个参数?答:字段
data=,文件files=。 - 上传大文件为什么推荐传句柄?答:流式编码,避免整文件进内存。
04.7.20.1-011 压缩响应是自动解压的吗?
一句话结论
requests 会在请求头自动带上 Accept-Encoding: gzip, deflate,响应体如果是 gzip/deflate,访问 response.content/response.text 时由 urllib3 自动解压;br(Brotli)支持取决于是否安装 brotli 依赖,未安装时不应假设能自动解压。
概念解释
- 压缩发生在传输层,目的是减小报文体积;解压对业务透明。
- 自动解压只覆盖 urllib3 识别的编码,未知编码会保留原始字节。
- 下载原始压缩包(如
.gz文件本身)时不要依赖自动解压,应直接落盘字节。
原理流程
- 请求阶段客户端声明可接受的压缩编码。
- 服务端按
Content-Encoding压缩 body 返回。 - urllib3 读取 body 后按编码解压,
response.content拿到解压后字节。 - 无法识别的编码保留压缩字节,由调用方处理。
代码或图示
import requests
r = requests.get("https://example.com/api", timeout=5)
print(r.headers.get("Content-Encoding"))
print(r.text) # 已解压文本
常见误区
- 以为所有压缩格式都开箱即用:br 需要额外安装 brotli 包,否则服务端可能不返回 br。
- 把自动解压后的内容再压缩一次:重复压缩浪费 CPU。
- 保存原始压缩文件时读了
r.content:已被解压,文件损坏。
追问
- 自动解压由谁完成?答:urllib3 在读取响应体时按 Content-Encoding 解压。
- br 支持缺什么?答:需要安装 brotli 相关依赖,否则不识别。
- 想保存原始 gz 文件怎么办?答:直接写
r.content原始字节,不要经过文本属性。
04.7.20.1-012 响应编码乱码怎么判断?
一句话结论
response.encoding 来自响应头 Content-Type 的 charset,缺失时 requests 会按 ISO-8859-1 猜测;中文接口若未声明编码,应先看 apparent_encoding(基于字节内容探测)再显式赋值,否则 response.text 出现乱码。
概念解释
response.encoding:用于解码response.text,可手动覆盖。response.apparent_encoding:chardet/charset-normalizer 探测结果,慢于头信息但更准。response.content始终是原始字节,不受编码影响。
原理流程
- 读取响应头,解析 charset 写入
response.encoding。 - 无 charset 时按默认推断,解码
text。 - 发现乱码后,用
apparent_encoding探测并回写response.encoding。 - 重新取
response.text得到正确文本。
代码或图示
import requests
r = requests.get("https://example.com/legacy-page", timeout=5)
if r.encoding is None or r.encoding == "ISO-8859-1":
r.encoding = r.apparent_encoding
print(r.text)
常见误区
- 直接改
r.content.decode("utf-8")而不确认真实编码:GBK 页面会二次乱码。 - 忽略响应头声明:探测结果只用于兜底,头里明确 charset 时应优先采信。
- 二进制接口也去猜编码:文件、图片应直接用
content字节处理。
追问
- text 与 content 区别?答:text 按 encoding 解码为字符串,content 是原始字节。
- 探测编码用什么属性?答:
apparent_encoding,底层字符集探测。 - 头里没 charset 默认按什么?答:requests 历史默认 ISO-8859-1(待确认:验证点:当前版本对文本响应的默认推断规则)。
04.7.20.1-013 超时 connect/read 分级与异常类型怎么区分?
一句话结论
timeout=(connect, read) 分别约束 TCP/TLS 握手等待与每次读取等待;连接阶段失败抛 ConnectionError 子类,读取阶段超时抛 ReadTimeout,整体超时按阶段归类,调用方可以分别处理重试与告警。
概念解释
ConnectTimeout:连接阶段超时,属于ConnectionError与TimeoutError链路。ReadTimeout:已建立连接后读取数据超时。ConnectionError覆盖 DNS 失败、拒绝连接、重置等连接层问题。
原理流程
- 传入二元组超时:第一个是 connect,第二个是 read。
- 握手阶段超过 connect 上限抛
ConnectTimeout。 - 连接建立后两次读取间隔超过 read 上限抛
ReadTimeout。 - 业务层按异常类型决定重试、降级还是直接失败。
代码或图示
import requests
from requests.exceptions import ConnectTimeout, ReadTimeout, ConnectionError
try:
r = requests.get("https://example.com", timeout=(3, 10))
except ConnectTimeout:
# 握手失败,可重试
...
except ReadTimeout:
# 响应中途停滞,按业务决定是否重试
...
except ConnectionError:
# DNS / 拒绝 / 重置
...
常见误区
- 只捕获
requests.Timeout:它同时是 ConnectTimeout 与 ReadTimeout 的父类,无法区分阶段。 - 把读超时当成总耗时:长响应分块返回时,每次块间隔独立计时。
- 不区分异常一律重试:连接拒绝可能是配置错误,重试无意义。
追问
- 二元组超时两个值分别是什么?答:connect 与 read,单位秒。
- ReadTimeout 什么时候触发?答:连接建立后两次读取之间超过 read 上限。
- 为什么要分开捕获?答:区分握手失败与中途停滞,重试与告警策略不同。
04.7.20.1-014 重试为什么必须以幂等为前提?
一句话结论
重试意味着同一个请求可能被执行多次,只有接口具备幂等性(重复调用结果等价于一次)才安全;GET/HEAD/OPTIONS 通常只读可安全重试,POST/PATCH/DELETE 是否幂等要看业务语义,不能按方法名一概而论。
概念解释
- 幂等:
f(x)调用一次与调用 N 次对系统的最终状态相同。 - 非幂等副作用:重复创建订单、重复扣款、重复发消息。
- 触发重试的场景:网络超时、连接重置、502/503,这些情况下服务端可能已经执行成功。
原理流程
- 一次请求发出后网络中断,客户端不知道服务端是否已处理。
- 若请求非幂等,重试会产生第二次副作用。
- 设计上通过业务幂等键(请求 ID、唯一单号)让服务端去重。
- 重试策略只对确认幂等的方法或带幂等键的写操作开启。
代码或图示
# 安全:只读,可重试
# 谨慎:写操作需带服务端可识别的幂等键
payload = {"order_id": "ORDER-20261119-001", "amount": 100}
r = requests.post("https://example.com/orders", json=payload, timeout=5)
常见误区
- 认为 DELETE 一定幂等:按规范是,但业务实现可能重复删除关联数据。
- 用客户端状态判断“没成功”:超时不代表服务端没执行。
- 不做幂等键就对写接口重试:重复副作用只能靠事后对账修复。
追问
- 什么是幂等?答:多次调用的最终状态与一次相同。
- 写接口怎么做到可重试?答:服务端基于唯一幂等键去重,重复请求返回首次结果。
- 网络超时后服务端一定没处理吗?答:不一定,请求可能已到达并执行。
04.7.20.1-015 连接池耗尽有什么表现,怎么调优?
一句话结论
池内连接被挂起请求占满后,新请求要么阻塞等待、要么新建连接导致 fd 上涨;表现为响应变慢、Connection pool is full 类告警、内存与连接数持续增长。调优方向是缩短超时、提高 pool_maxsize、修复泄漏的响应,并限制总并发。
概念解释
- 池耗尽本质是“借出连接未归还”速度跟不上“新借连接”速度。
- 常见原因:响应未关闭、请求无超时长期挂起、并发量超过池上限。
- 调优必须结合下游承载,盲目加大池只会把压力转移到对端。
原理流程
- 请求占用连接后阻塞在慢响应上,连接迟迟不归还。
- 并发请求把池内连接全部占满。
- 按
pool_block行为阻塞等待或新建连接。 - 定位慢请求与未关闭响应,调整超时、池大小与并发上限。
代码或图示
慢响应占住连接 → 池满 → 阻塞等待 / 新建连接 → fd 与内存上涨 → 拒绝服务
常见误区
- 一出问题就调大
pool_maxsize:根因若是超时缺失,加大池只会延后爆发。 - 忽略响应关闭路径:异常分支泄漏连接,池使用率长期居高不下。
- 多进程部署时按单机配置池:总连接数 = 进程数 × 池大小,要核对下游上限。
追问
- 池耗尽最先看什么?答:响应是否关闭、超时是否配置、并发是否超上限。
- 多进程下总连接数怎么算?答:进程数 × 每进程池大小,需 ≤ 下游连接容量。
- pool_block=True 耗尽时会怎样?答:调用方阻塞等待连接归还,延迟上升。
04.7.20.1-016 Session 能否多线程共享?
一句话结论
Session 内部连接池基于 urllib3,在多线程场景下通常可以共享使用,连接池本身做了并发控制;但 Session 上可变状态(自定义头、Cookie、挂载的适配器)在并发修改时需要自己加锁,且按账号/租户隔离的会话不应共用一个实例。
概念解释
- 只读地复用连接池与默认配置:多线程共用是常见做法。
- 并发写
session.headers/session.cookies:没有原子保护,可能出现竞态。 - 长服务里 Session 生命周期应覆盖整个应用,而不是每请求新建(浪费握手)也不是跨业务混用。
原理流程
- 工作线程从同一 Session 取连接,连接池分配/归还连接。
- 默认头与 Cookie 作为请求基准被读取。
- 若某线程修改共享可变状态,其他线程可能读到中间态。
- 多账号场景按会话创建独立 Session,隔离凭证与连接。
代码或图示
import threading, requests
session = requests.Session()
def worker():
r = session.get("https://example.com", timeout=5)
return r.status_code
threads = [threading.Thread(target=worker) for _ in range(10)]
常见误区
- 把每请求新建 Session 当成安全做法:重复握手,吞吐明显下降。
- 不同认证用户共用 Session:Cookie 与头串号。
- 在请求回调里改写全局 Session 头:并发下影响其他线程。
追问
- 共享 Session 主要复用什么?答:连接池、默认头与 Cookie Jar。
- 什么状态要避免并发改?答:headers、cookies、挂载的适配器。
- 多租户怎么隔离?答:按租户/账号创建独立 Session,凭证不混用。
04.7.20.1-017 requests 的底层调用链是什么?
一句话结论
调用 Session.request 构造 PreparedRequest,经 HTTPAdapter.send 交给 urllib3 的 HTTPConnectionPool 取连接、发送请求并返回 Response;requests 负责 API 与 cookie/认证,urllib3 负责连接管理与协议细节,底层再到 http.client 与 socket。
概念解释
PreparedRequest:把方法、URL、头、body 预处理成可发送形态。HTTPAdapter:requests 与 urllib3 之间的适配层,可挂载重试与池参数。- urllib3 连接池管理 keep-alive 连接,http.client 处理报文,socket 负责字节收发。
原理流程
Session.request合并默认头与参数,构造PreparedRequest。- 请求经挂载的
HTTPAdapter.send发出。 - adapter 从 urllib3 连接池取/建连接,发送报文。
- 响应流回,包装成
requests.Response返回给调用方。
代码或图示
Session.request → PreparedRequest → HTTPAdapter.send
→ urllib3 ConnectionPool → http.client → socket
→ Response
常见误区
- 以为 requests 直接操作 socket:中间隔了 adapter、urllib3、http.client 多层。
- 自定义行为只改 Session:拦截协议层要通过自定义
HTTPAdapter。 - 排查连接问题时不看 urllib3 日志:连接池与重试信息在底层更完整。
追问
- PreparedRequest 做什么?答:预处理方法、URL、头与 body 为可发送请求。
- 适配器在链路哪一层?答:requests 与 urllib3 之间,承载池与重试配置。
- 谁管理 keep-alive 连接?答:urllib3 连接池。
04.7.20.1-018 证书校验失败有哪些异常?
一句话结论
证书链不受信、证书过期、主机名不匹配分别抛出 SSLError 的不同子类或包装异常;DNS 失败、连接拒绝属于 ConnectionError,不要和证书问题混为一类处理。
概念解释
- 证书链错误:缺少可信根或中间证书,验签失败。
- 过期/未生效:证书时间不在有效期内。
- 主机名不匹配:证书 SAN/主题与请求域名不一致。
原理流程
- TLS 握手下发证书链。
- 信任链验签失败抛出证书错误。
- 有效期检查失败抛出过期类错误。
- 主机名校验失败抛出匹配错误,统一可被
requests.exceptions.SSLError捕获。
代码或图示
import requests
from requests.exceptions import SSLError
try:
requests.get("https://expired.example.com", timeout=5)
except SSLError as e:
# 含证书链、过期、主机名不匹配等 SSL 层问题
print(e)
常见误区
- 遇到 SSL 错误直接
verify=False:绕过校验而不修信任链,生产留隐患。 - 把证书错误当网络错误重试:重试无法修复配置问题。
- 中间证书未部署:客户端报链不受信,问题在服务端证书配置。
追问
- 主机名不匹配属于哪类错误?答:SSL 校验错误,SSLError 链路。
- 信任链不受信怎么修?答:补全中间证书或配置客户端信任根。
- 关校验能解决过期证书吗?答:只是跳过检查,风险仍在。
04.7.20.1-019 代理如何配置,环境变量如何介入?
一句话结论
requests 按 proxies= 参数配置代理,未显式配置时会读取 HTTP_PROXY/HTTPS_PROXY 等环境变量;代理凭证可以写在 URL 里,NO_PROXY 控制绕过列表,容器与开发机的代理差异容易导致连不通。
概念解释
proxies={"http": "http://127.0.0.1:8080", "https": "..."}按 scheme 分流。- 环境变量默认被信任,CI/容器里预置的代理可能影响本地请求。
- 代理鉴权:
http://user:pass@host:port形式传入。
原理流程
- 检查请求是否在
NO_PROXY绕过列表。 - 取显式
proxies配置,没有则读环境变量。 - 按 scheme 选择代理地址,建立到代理的隧道连接。
- HTTPS 通过 CONNECT 隧道转发原始 TLS 流量。
代码或图示
import requests
proxies = {"https": "http://proxy.example.com:8080"}
r = requests.get("https://example.com", proxies=proxies, timeout=5)
# 环境变量示例(不入代码仓库)
# HTTPS_PROXY=http://proxy.example.com:8080
# NO_PROXY=localhost,internal.example.com
常见误区
- 容器里不通也不查代理:环境变量代理把流量发到不可达地址。
- 代理凭证硬编码进代码:应走环境变量或密钥管理。
- 以为 HTTPS 代理能看到明文内容:CONNECT 隧道内仍是端到端 TLS。
追问
- 代理配置优先级?答:显式
proxies=高于环境变量。 - NO_PROXY 作用?答:匹配到的主机绕过代理直连。
- HTTPS 代理怎么转发?答:CONNECT 建立隧道,内部 TLS 不变。
04.7.20.1-020 请求钩子 hooks 与 prepare_request 有什么用?
一句话结论
hooks={"response": fn} 在响应返回后插入统一处理(日志、错误断言、指标),Request.prepare/Session.prepare_request 则把请求预处理成 PreparedRequest,便于复用同一套拼装逻辑做重试、转发或自定义发送。
概念解释
- response 钩子接收响应对象,可读取头/体并补充标记。
- 钩子适合放横切关注点:记录耗时、按状态码抛异常、采集指标。
PreparedRequest可在多适配器、多会话之间复用拼装结果。
原理流程
- 请求构造完成后注册 response 钩子。
- 响应返回后依次调用钩子函数。
- 钩子可改写响应或附加属性,再返回给业务代码。
- 需要重发时基于
PreparedRequest复用已预处理报文。
代码或图示
import requests
def log_hook(resp, *args, **kwargs):
print(resp.request.url, resp.status_code, resp.elapsed)
s = requests.Session()
s.hooks["response"].append(log_hook)
r = s.get("https://example.com", timeout=5)
常见误区
- 在钩子里做重业务或阻塞操作:拖慢所有请求链路。
- 钩子吞掉异常:响应错误被静默,上层感知不到失败。
- 把业务判断写进钩子:横切逻辑与业务耦合,难以测试。
追问
- hooks 支持哪些事件?答:常用 response 钩子(待确认:验证点:当前版本支持的钩子事件类型)。
- PreparedRequest 什么时候复用?答:需要在不同发送路径重发同一请求时。
- 钩子适合放什么?答:日志、指标、统一错误断言等横切逻辑。
04.7.20.1-021 会话级默认头、Cookie 与认证怎么设置?
一句话结论
Session.headers.update 设默认请求头,Session.cookies 直接写入 Cookie,认证可用 Session.auth 或各请求的 auth= 参数;会话级配置对后续所有请求生效,代码比每次重复传头更一致,也避免漏带凭证。
概念解释
- 默认头与单次请求头合并,单次参数可覆盖会话默认值。
- 认证三种方式:
auth=基本认证元组、会话级auth、手动在头里放 Bearer token。 - 凭证不写进代码仓库,应从环境变量或密钥管理读取。
原理流程
- 创建 Session,更新默认头与 Cookie。
- 设置会话级认证回调或元组。
- 后续请求自动合并默认头、Cookie 与认证信息。
- 单次请求需要覆盖时,在该调用上传同名参数。
代码或图示
import requests
s = requests.Session()
s.headers.update({"X-Client": "order-service/1.0"})
s.cookies.set("sid", "token-value")
s.auth = ("user", "password")
r = s.get("https://example.com/me", timeout=5)
常见误区
- 把长期 token 存进全局 Session 后不刷新:过期后请求持续 401。
- 会话头与单次头同名时不清楚谁覆盖谁:单次请求参数优先。
- 硬编码账号密码进源码:违反凭证管理边界,应走配置注入。
追问
- 单次请求头能覆盖会话默认头吗?答:能,单次参数优先级更高。
- auth 支持哪些形式?答:基本认证元组、可调用认证对象,或手动写 Authorization 头。
- 凭证应该放在哪里?答:环境变量/密钥管理,不进仓库与代码。
04.7.20.1-022 自定义 HTTPAdapter 能拦截什么?
一句话结论
继承 HTTPAdapter 可以重写 send/init_poolmanager 等方法,在请求发出前后插入日志、指标、重试装饰、连接池定制或协议替换;它是 requests 扩展传输层的标准落点,业务横切逻辑不应该散落在各个调用处。
概念解释
- adapter 绑定到 scheme(http/https),同一前缀下所有请求经过它。
- 可观测性:在
send前后记录耗时、状态码、异常类型。 - 连接管理:重写池管理器参数,按目标主机差异化配置。
原理流程
- 子类继承
HTTPAdapter,重写需要介入的方法。 - 在重写方法里调用
super().send(...)保留默认行为。 - 挂载到 Session 的对应 scheme。
- 横切逻辑在适配器层统一生效,业务代码只关心业务。
代码或图示
import time, requests
from requests.adapters import HTTPAdapter
class TimingAdapter(HTTPAdapter):
def send(self, request, **kwargs):
start = time.perf_counter()
resp = super().send(request, **kwargs)
print(request.url, resp.status_code, time.perf_counter() - start)
return resp
s = requests.Session()
s.mount("https://", TimingAdapter())
常见误区
- 重写
send不调用父类:连接池与重试行为丢失。 - 在适配器里做业务校验:传输层不应理解业务语义。
- 同一 Session 挂载多个同 scheme 适配器:后挂载覆盖先挂载。
追问
- adapter 挂载按什么匹配?答:按 URL scheme,http/https 分别挂载。
- 重写 send 为什么要调 super?答:保留连接池、重试与默认发送逻辑。
- 统一耗时日志放哪层合适?答:传输适配器或上层客户端封装。
04.7.20.1-023 大请求体流式上传怎么控制内存?
一句话结论
上传大文件时把打开的文件句柄交给 files/data,requests/urllib3 按流编码发送;不要先 read() 成字节串再传,避免整文件驻留内存。请求体很大时还要关注服务端接收限制与发送超时。
概念解释
- 流式句柄:边读边编码边发送,内存占用与块大小相关。
- 预读成 bytes:整文件进入进程内存,大文件直接 OOM。
- 发送超时要比下载场景留足余量,慢速上传容易触发 write 阶段等待。
原理流程
- 以二进制模式打开文件,保留句柄。
- 请求构造时传入句柄作为文件字段。
- 传输层按块读取、编码、发送。
- 发送完成后关闭句柄,异常路径用
with保证释放。
代码或图示
import requests
with open("archive.tar.gz", "rb") as f:
r = requests.post(
"https://example.com/upload",
files={"archive": f},
timeout=(3, 120),
)
常见误区
data=open(...).read():文件内容一次性进内存。- 上传超时沿用下载的 read 超时:慢上传在写阶段卡住。
- 不校验服务端大小限制:传到一半被断开,前功尽弃。
追问
- 流式上传为什么省内存?答:按块读取发送,不整文件驻留。
- 发送阶段超时叫什么?答:连接/写阶段等待,需在超时参数里覆盖。
- 大文件上传更稳的方案?答:分片上传、断点续传,由服务端配合。
04.7.20.1-024 请求与响应 body 的内存边界怎么估算?
一句话结论
同步下载默认把整个响应体读进内存,内存占用 ≈ 响应体大小;流式处理后内存 ≈ 块大小 × 缓冲区。服务端接口应限制可下载体积,客户端也要按“最大响应大小”设计接收与超时策略。
概念解释
response.content:完整 body 的字节串,大响应直接放大堆内存。- 流式迭代:
iter_content块大小可控,配合落盘避免堆积。 - 并发场景下内存 = 单连接 body 占用 × 并发数,相乘后才是峰值。
原理流程
- 判断响应是否可能很大(文件下载、分页报表、日志导出)。
- 大 body 强制
stream=True,按块写入目标。 - 按并发数估算峰值内存,设上限保护进程。
- 服务端对响应体积做分页或压缩,避免无界返回。
代码或图示
内存峰值 ≈ 单请求 body 大小 × 并发连接数
流式后 ≈ 块大小 × 并发连接数
常见误区
- 只看单次响应大小,不乘并发数:批量拉取时内存翻倍上涨。
- 接口不做大小限制:恶意大响应可以打垮客户端进程。
- 解压后体积膨胀:压缩包很小但解压后巨大,需按解压后估算。
追问
- 默认下载 body 放哪?答:
response.content,整段进入内存。 - 流式后内存由什么决定?答:块大小与并发连接数。
- 服务端怎么防大响应?答:分页、大小上限、压缩与流式导出。
04.7.20.1-025 httpx 同步与异步 API 如何划分?
一句话结论
httpx 提供 Client(同步)与 AsyncClient(异步)两套对等 API:方法名与参数基本一致,同步用 with Client() as c:,异步用 async with AsyncClient() as c: 并 await 请求方法;同一代码路径不要混用同步客户端与事件循环。
概念解释
- 双 API 设计:业务可以从同步逐步迁移到异步,接口形态一致。
- 异步客户端方法是协程,必须
await;同步客户端方法阻塞执行。 - 底层传输层不同:同步走线程/阻塞 IO,异步走事件循环与非阻塞 IO。
原理流程
- 按运行环境选择
Client或AsyncClient。 - 客户端在上下文管理器中创建,复用连接池。
- 调用对应请求方法,异步版本加
await。 - 退出上下文时关闭连接池,释放底层资源。
代码或图示
import httpx
# 同步
with httpx.Client(timeout=5) as client:
r = client.get("https://example.com")
# 异步
import asyncio
async def main():
async with httpx.AsyncClient(timeout=5) as client:
r = await client.get("https://example.com")
asyncio.run(main())
常见误区
- 在 async 函数里用同步
Client:阻塞事件循环,并发能力丧失。 - 忘记
await异步请求方法:拿到协程对象而非响应。 - 每次请求新建客户端:丢失连接复用,握手开销翻倍。
追问
- 两套客户端 API 差异大吗?答:方法名与参数基本对等,异步需 await。
- 异步客户端为什么必须上下文管理?答:退出时关闭连接池与传输层。
- 同步客户端能跑在 async loop 里吗?答:会阻塞 loop,应换 AsyncClient。
04.7.20.1-026 AsyncClient 生命周期与连接复用怎么管理?
一句话结论
AsyncClient 应在应用生命周期内创建一次并复用,用 async with 或在启动/关闭钩子中 aclose();内部连接池随客户端存活,反复创建会反复握手,客户端未关闭则连接与事件循环资源泄漏。
概念解释
- 长生命周期客户端:池内 keep-alive 连接被多次请求复用。
- 与事件循环绑定:异步客户端的连接属于创建它的 loop,不能跨 loop 传递。
- Web 框架中通常在 lifespan 启动时创建,关闭时
aclose()。
原理流程
- 应用启动阶段创建
AsyncClient,配置超时与连接池。 - 各请求复用同一客户端,走池内连接。
- 事件循环停止前调用
aclose()关闭连接池。 - 上下文管理器退出时自动执行关闭。
代码或图示
import httpx, asyncio
async def main():
async with httpx.AsyncClient() as client:
r1 = await client.get("https://example.com/a")
r2 = await client.get("https://example.com/b")
常见误区
- 请求函数内每次
AsyncClient():连接不复用,且产生未关闭警告。 - 客户端实例跨事件循环复用:底层连接归属旧 loop,行为未定义。
- 进程退出不显式关闭:可能看到未关闭连接的资源警告。
追问
- 客户端什么时候创建一次?答:应用启动后、请求处理前,全局或按模块复用。
- AsyncClient 能跨 loop 用吗?答:不能,连接绑定创建时的事件循环。
- 如何显式关闭?答:
await client.aclose(),或用async with。
04.7.20.1-027 Limits 连接池参数有哪些?
一句话结论
httpx.Limits(max_connections=100, max_keepalive_connections=20, keepalive_expiry=5) 分别限制总并发连接数、空闲保活连接数与保活时长;参数语义与 urllib3 池对应,异步场景下池大小直接决定并发上限。
概念解释
max_connections:同一客户端允许的最大并发连接。max_keepalive_connections:空闲后保留的 keep-alive 连接上限,应 ≤ 总上限。keepalive_expiry:空闲连接保留秒数,超时关闭避免半开连接。
原理流程
- 创建客户端时传入
limits=Limits(...)。 - 新请求按池参数取/建连接,并发不超过
max_connections。 - 空闲连接按
keepalive_expiry超时回收。 - 池满时新请求等待连接归还,受超时对象的
pool超时约束。
代码或图示
import httpx
limits = httpx.Limits(max_connections=50, max_keepalive_connections=10, keepalive_expiry=10)
client = httpx.Client(limits=limits, timeout=5)
常见误区
max_keepalive_connections大于max_connections:配置矛盾,保活数被总上限约束。- 池大小不评估下游容量:并发连接压垮对端。
- 忽略 pool 超时:池满时等待连接也可能无限阻塞。
追问
- max_connections 控制什么?答:客户端最大并发连接数。
- keepalive_expiry 作用?答:空闲连接保留时长,超时关闭。
- 池满等待受哪个超时约束?答:超时对象的
pool字段。
04.7.20.1-028 HTTP/2 如何启用,依赖什么?
一句话结论
httpx 默认走 HTTP/1.1,启用 HTTP/2 需要创建客户端时传 http2=True,并额外安装 h2 依赖;服务端必须也支持 HTTP/2,协商失败会回退,客户端代码不需要为协议版本改业务调用。
概念解释
- HTTP/2:单连接多路复用、头部压缩,适合高并发多请求场景。
- 依赖:
h2包提供 HTTP/2 协议实现,未安装时http2=True会报错或不可用(待确认:验证点:未装 h2 时的具体行为是抛错还是静默回退)。 - 浏览器/网关链路是否 h2 取决于整条链路,客户端启用只保证到下一跳。
原理流程
- 安装
h2,客户端配置http2=True。 - TLS 握手时 ALPN 协商协议版本。
- 服务端支持则升级到 HTTP/2,多路复用同一连接。
- 不支持则按协商结果回退到 HTTP/1.1。
代码或图示
# 安装依赖:pip install h2
import httpx
client = httpx.Client(http2=True, timeout=5)
r = client.get("https://example.com")
print(r.http_version) # 协商结果,如 HTTP/2
常见误区
- 只开
http2=True不装h2:协议实现缺失,无法建立 h2 连接。 - 以为开了 h2 所有请求都 h2:仍需服务端与中间链路支持。
- 用 h2 长连接承载大文件:h2 单流被慢响应阻塞,多路复用收益受限。
追问
- h2 依赖哪个包?答:
h2,需单独安装。 - 怎么看实际协商版本?答:响应对象的
http_version属性。 - 服务端不支持会怎样?答:ALPN 协商后回退到 HTTP/1.1。
04.7.20.1-029 httpx 超时对象如何分级?
一句话结论
httpx.Timeout(connect=..., read=..., write=..., pool=...) 分别控制连接建立、读取、写入与等待池内连接的超时;传单个数值 timeout=5 是四项统一取值,默认客户端超时为 5 秒(待确认:验证点:当前版本默认超时数值)。
概念解释
connect:建连握手等待。read/write:已建连后读写等待。pool:从连接池等待可用连接的时间,池拥塞时生效。
原理流程
- 构造
Timeout对象或直接传数值。 - 各阶段等待超过对应字段即抛
httpx.ConnectTimeout/ReadTimeout/WriteTimeout/PoolTimeout。 - 业务按异常类型区分建连失败、读写停滞与池拥塞。
- 超时对象可在客户端默认值与单次请求参数上覆盖。
代码或图示
import httpx
timeout = httpx.Timeout(connect=3, read=10, write=10, pool=5)
client = httpx.Client(timeout=timeout)
# 单次覆盖
r = client.get("https://example.com", timeout=httpx.Timeout(connect=2, read=8))
常见误区
- 只设 read 不设 pool:池满等待仍可能拖长。
- 用总耗时理解分段超时:各阶段独立计时,不是请求上限。
- 异步下省略超时:协程挂起同样堆积,只是表现为任务队列变长。
追问
- pool 超时什么时候触发?答:池满,等待连接归还超过 pool 上限。
- 单个 timeout 值代表什么?答:四项统一取值。
- 超时异常分哪几类?答:Connect/Read/Write/Pool 四种超时。
04.7.20.1-030 httpx 与 requests 的 API 有哪些差异?
一句话结论
两者请求方法、response.json()、头/Cookie 访问大体一致;差异集中在:httpx 原生异步、超时对象分级、HTTP/2 支持、response.url 是 URL 对象,以及部分行为(如默认环境变量信任、重定向处理细节)需要对照文档,迁移时不要假设 100% 等价。
概念解释
- 共性:
get/post/put/delete、headers、cookies、status_code、text/content。 - 差异:httpx 客户端需显式创建并关闭;超时用
Timeout对象;URL 不可变对象。 - 测试替换:httpx 提供
MockTransport,便于不打真实网络。
原理流程
- 迁移时先核对同步客户端调用方式与返回类型。
- 异步路径改用
AsyncClient并补await。 - 检查超时、代理、证书等参数写法差异。
- 用传输层 mock 做回归测试,确认响应解析一致。
代码或图示
import httpx
with httpx.Client() as c:
r = c.get("https://example.com")
r.json()
str(r.url)
常见误区
- 认为 requests 代码可以无改动跑在 httpx:个别参数与默认行为不同。
- 直接复用 requests 的 Session 概念:httpx 客户端模型更接近
Client实例。 - 忽略版本差异:httpx 0.27+ 的参数与行为以当前文档为准。
追问
- 两者最核心的能力差异?答:httpx 原生异步、HTTP/2、分级超时对象。
- httpx 怎么做网络隔离测试?答:注入
MockTransport或自定义 transport。 - 迁移时先核对什么?答:超时、代理、证书、URL 类型等参数与默认行为。
04.7.20.1-031 httpx 流式响应怎么读?
一句话结论
httpx 用 client.stream("GET", url) 进入流式上下文,响应体通过 response.iter_bytes()/iter_text()/iter_lines() 分块读取;与 requests 一样,流式响应必须在上下文内处理完,避免 body 未读完导致连接无法复用。
概念解释
stream()上下文管理器:退出时保证响应与连接被正确释放。- 迭代器按块产出,内存占用与块大小相关。
- 需要先取响应头(状态码、Content-Length)再决定是否下载。
原理流程
- 进入
async with client.stream(...)或同步with client.stream(...)。 - 检查状态码与响应头。
- 调用
iter_bytes分块写入文件或转发。 - 退出上下文时关闭 body,连接归还池中。
代码或图示
import httpx
with httpx.Client() as client:
with client.stream("GET", "https://example.com/big.iso") as r:
r.raise_for_status()
with open("big.iso", "wb") as f:
for chunk in r.iter_bytes(1024 * 1024):
f.write(chunk)
常见误区
- 流式上下文里提前
return:body 未读完,连接不能复用。 - 用
r.text读大响应:整段进内存,流式失去意义。 - 异步版本忘记
async with/async for:协程未正确挂起。
追问
- 流式迭代器有哪几种?答:
iter_bytes、iter_text、iter_lines。 - body 不读完会怎样?答:连接无法归还复用,可能泄漏。
- 怎么先看头再决定下载?答:stream 上下文里先读 status 与 headers。
04.7.20.1-032 mounts、代理与 verify 怎么配置?
一句话结论
httpx 用 mounts={前缀: 客户端/传输} 按 URL 前缀分流连接池与配置,proxy= 配置代理,verify= 控制证书校验(True/False/CA 路径);不同目标环境(内网、外网、mock)可以挂不同传输,而不改动业务调用。
概念解释
- mounts:为特定前缀单独设置连接池、超时或传输,例如内网走直连、外网走代理。
- proxy:支持 HTTP 代理与环境变量代理,语义与 requests 对应。
- verify:证书校验开关或自定义 CA 路径,生产不应关闭。
原理流程
- 构造客户端时传入 mounts/proxy/verify。
- 请求 URL 按前缀匹配对应 mount 配置。
- TLS 阶段按 verify 配置校验证书链。
- 不匹配前缀的请求走默认客户端配置。
代码或图示
import httpx
client = httpx.Client(
verify="/etc/ssl/internal-ca.pem",
proxy="http://proxy.example.com:8080",
mounts={
"https://internal.example.com": httpx.Client(verify=True),
},
timeout=5,
)
常见误区
- 混用 proxy 与 mounts 不清楚优先级:前缀 mount 覆盖默认代理设置。
- 生产
verify=False:中间人风险同 requests 场景。 - 给内网地址也走外网代理:增加一跳延迟与失败点。
追问
- mounts 解决什么问题?答:按前缀差异化连接池、代理与传输配置。
- verify 可传什么?答:布尔值或本地 CA 证书路径。
- 代理支持环境变量吗?答:支持,显式参数优先(待确认:验证点:当前版本环境变量信任规则)。
04.7.20.1-033 httpx 传输层怎么做测试替换?
一句话结论
httpx 把网络发送抽象为 transport,测试时注入 MockTransport 或自定义 transport 返回固定响应,业务代码不打真实网络;这比 monkeypatch 请求方法更稳定,也能覆盖超时、错误响应等分支。
概念解释
MockTransport(handler=...):handler 接收请求实例,返回httpx.Response。- 自定义 transport:实现
handle_request/handle_async_request协议。 - 客户端通过
transport=参数接收替换对象,生产环境默认走网络传输。
原理流程
- 测试里构造 handler,按 URL 返回预设状态码与 body。
- 创建客户端时传入
transport=MockTransport(handler)。 - 业务调用客户端方法,响应来自 mock 而非网络。
- 断言请求方法、URL、头与发出的 body。
代码或图示
import httpx
def handler(request: httpx.Request) -> httpx.Response:
return httpx.Response(200, json={"ok": True})
client = httpx.Client(transport=httpx.MockTransport(handler))
r = client.get("https://example.com/api")
常见误区
- 在测试里 patch 全局
requests.get:漏改路径仍会打网络。 - mock 只返回成功分支:超时、5xx、连接错误分支没覆盖。
- 断言只看响应不看请求:发出的参数错误无法发现。
追问
- MockTransport 怎么构造响应?答:handler 返回
httpx.Response实例。 - 自定义 transport 要实现什么?答:同步/异步请求处理方法(待确认:验证点:当前版本 transport 协议方法名)。
- 测试能模拟超时吗?答:handler 抛对应超时异常或返回延迟响应。
04.7.20.1-034 aiohttp ClientSession 的连接复用模型是什么?
一句话结论
aiohttp.ClientSession 是异步 HTTP 客户端的主入口,内部通过 TCPConnector 维护连接池,同主机 keep-alive 连接在多次请求间复用;Session 应在应用生命周期内创建一次,并发请求由事件循环调度,连接由 connector 分配与回收。
概念解释
- Session 持有 connector、cookie jar、默认头与中间件钩子。
- 连接复用:与 urllib3 池模型类似,但跑在异步非阻塞 IO 上。
- Session 不是线程/协程局部对象,而是与事件循环绑定的长生命周期对象。
原理流程
- 应用启动时创建
ClientSession(connector=...)。 - 并发请求经 Session 提交,connector 从池中取/建连接。
- 响应返回后连接归还池,保持 keep-alive。
- 关闭应用时
await session.close()释放连接。
代码或图示
import aiohttp, asyncio
async def main():
async with aiohttp.ClientSession() as session:
async with session.get("https://example.com/a") as r1:
await r1.text()
async with session.get("https://example.com/b") as r2:
await r2.text()
asyncio.run(main())
常见误区
- 每请求新建 Session:连接不复用,且容易出现 loop 绑定问题。
- 响应不用
async with或不释放:连接占用不归还。 - 在多线程里共享同一 Session:aiohttp 会话设计为单事件循环使用。
追问
- 连接池由谁管理?答:传入 Session 的
TCPConnector。 - Session 什么时候关闭?答:应用退出前
await close(),或用async with。 - 一个 Session 能跨事件循环吗?答:不能,绑定创建时的 loop。
04.7.20.1-035 TCPConnector 的并发上限参数有哪些?
一句话结论
TCPConnector(limit=100, limit_per_host=0, ttl_dns_cache=...) 控制总并发连接数、单主机连接上限与 DNS 缓存时长;limit_per_host=0 表示不按主机限制,只受总 limit 约束,异步并发峰值由这两个参数兜底。
概念解释
limit:整个 connector 同时打开的最大连接数。limit_per_host:单个目标主机的最大连接数,防止下游被单一调用方打满。- DNS 缓存:减少重复 DNS 查询,ttl 内复用解析结果。
原理流程
- 创建 connector 时设定总与单主机上限。
- 新请求取连接时先检查是否触达上限。
- 触达则等待连接归还,或受客户端超时约束。
- DNS 结果按 ttl 缓存,过期重新解析。
代码或图示
import aiohttp
connector = aiohttp.TCPConnector(limit=50, limit_per_host=10, ttl_dns_cache=300)
session = aiohttp.ClientSession(connector=connector)
常见误区
- 只设总 limit 不设 per_host:某一下游占用全部连接,其他请求排队。
- 并发量超过 limit 不做排队控制:协程大量等待,内存与延迟上涨。
- 连接器随 Session 反复新建:池状态全部丢失。
追问
- limit 与 limit_per_host 区别?答:总连接上限 vs 单主机上限。
- limit_per_host=0 是什么含义?答:不按主机限制。
- DNS 缓存由哪个参数控制?答:
ttl_dns_cache,单位秒。
04.7.20.1-036 ClientSession 与事件循环绑定有什么坑?
一句话结论
ClientSession 在创建时绑定当前运行的事件循环,连接、cookie 与内部状态都归该 loop;把 Session 拿到另一个 loop 或在线程间复用,会出现“Session is bound to a different event loop”类错误或未定义行为。
概念解释
- 异步对象(连接、信号量、队列)内部使用 loop 原语,跨 loop 无法安全共享。
- 测试里反复
asyncio.run会创建新 loop,复用旧 Session 必报错。 - 正确做法:一个应用进程内一个 loop,Session 随 loop 创建与关闭。
原理流程
- Session 创建时记录当前 loop 引用。
- 后续协程在同一 loop 上调度,复用连接与状态。
- 切换 loop 后内部原语归属不匹配,抛出绑定错误。
- 需要隔离时按 loop 创建独立 Session,结束后关闭。
代码或图示
import aiohttp, asyncio
async def make_session():
return aiohttp.ClientSession()
async def main():
session = await make_session()
await session.get("https://example.com")
await session.close()
asyncio.run(main())
常见误区
- 模块级全局 Session 在导入时创建:没有运行中的 loop,绑定时机错误。
- 在线程池任务里复用主 loop 的 Session:跨线程调度冲突。
- 关闭后复用 Session:内部连接已释放,行为异常。
追问
- 跨 loop 复用会报什么?答:事件循环绑定不一致类错误(待确认:验证点:当前版本异常类名与提示文本)。
- 模块级 Session 为什么危险?答:导入时没有 loop,创建时机错误。
- 多隔离场景怎么做?答:每个 loop 独立 Session,用完关闭。
04.7.20.1-037 aiohttp 超时与流式读取怎么配置?
一句话结论
aiohttp 用 ClientTimeout(total=..., connect=..., sock_read=..., sock_connect=...) 分级控制超时;响应体通过 resp.text()/resp.read()/resp.content.iter_chunked() 读取,大文件用分块迭代避免整段进内存。
概念解释
total:整体最长耗时;connect/sock_connect:建连;sock_read:两次读取间隔。resp.content是流式读取对象,iter_chunked按块产出字节。- 响应未释放时连接不归还,异常路径要确保关闭。
原理流程
- 创建 Session 时传入
timeout=ClientTimeout(...),或单次请求覆盖。 - 请求建立后按各阶段超时等待。
- 大 body 用
iter_chunked分块落盘。 - 响应上下文退出后连接归还 connector 池。
代码或图示
import aiohttp, asyncio
timeout = aiohttp.ClientTimeout(total=30, connect=5, sock_read=10)
async def download(session, url):
async with session.get(url, timeout=timeout) as resp:
with open("big.iso", "wb") as f:
async for chunk in resp.content.iter_chunked(1024 * 1024):
f.write(chunk)
常见误区
- 只设
total不设读超时:慢速连接可以拖到整体超时才退出。 resp.read()读大文件:整段 body 进内存。- 超时配置只在 Session 设,单次慢请求无法收紧覆盖。
追问
- ClientTimeout 分哪些字段?答:total、connect/sock_connect、sock_read(待确认:验证点:字段命名与默认值)。
- 分块迭代用什么方法?答:
resp.content.iter_chunked(块大小)。 - 响应不关闭有什么后果?答:连接不归还,池逐步耗尽。
04.7.20.1-038 aiohttp 与 httpx 异步客户端怎么选?
一句话结论
两者都是成熟异步 HTTP 客户端:httpx API 与 requests 对齐、同步/异步双栈、内置 HTTP/2 与 mock 传输,适合新服务与测试友好场景;aiohttp 生态更早、连接器配置细、常与 aiohttp 服务端配套,适合已有该栈的项目。选型看团队熟悉度、协议需求与测试方式,不要为单一功能换栈。
概念解释
- httpx:双 API、分级超时、
MockTransport、HTTP/2,异步体验统一。 - aiohttp:客户端与服务端同生态,connector 粒度细,社区案例多。
- 两者都需要长生命周期 Session/Client 与显式超时。
原理流程
- 列出需求:同步兼容、HTTP/2、代理、流式、测试 mock、服务端配套。
- 对照两库能力与团队既有经验。
- 小范围验证连接复用、超时与错误分支行为。
- 统一封装一层客户端,底层可替换。
代码或图示
需求:异步调用 + 测试隔离 → httpx
需求:与 aiohttp 服务端同栈、细粒度连接器 → aiohttp
常见误区
- 按“谁性能高”选客户端:差距通常小于下游网络与业务处理,基准测试要按自己场景做。
- 混用两库的 Session 概念:生命周期与关闭方式不同。
- 封装层直接暴露底层类型:后续替换成本高,应抽象出方法接口。
追问
- httpx 相对 aiohttp 的优势?答:双 API、HTTP/2、内置 mock 传输。
- aiohttp 适合什么存量场景?答:已有 aiohttp 服务端、连接器调优经验的项目。
- 选型前必须验证什么?答:连接复用、超时行为、错误分支与自己场景的吞吐。
04.7.20.1-039 标准 json 与 orjson/ujson/msgspec 性能与兼容差异是什么?
一句话结论
标准库 json 兼容性最好、零依赖;orjson/ujson 用 C/Rust 实现提速序列化与反序列化;msgspec 偏向 schema 化二进制编码(msgpack 风格)。性能排序在不同负载下会变,选型先看类型兼容、输出格式与依赖约束,而不是只看 benchmarks。
概念解释
- 标准 json:纯 Python 实现,支持类型最全,无额外依赖。
- orjson:Rust 实现,返回 bytes,速度快,但部分 Python 类型需显式处理。
- ujson:C 实现,轻量快,类型保真度与边界行为弱于标准库。
- msgspec:用
Struct定义 schema,编码为紧凑二进制,解码直接成对象。
原理流程
- 按接口对外格式选:对外 JSON 用 json/orjson/ujson;内部高性能通信可用 msgspec。
- 压测序列化/反序列化耗时与内存占用。
- 核对边界类型:日期、Decimal、字节、自定义类、NaN。
- 保留标准库作为兜底实现,方便回退。
代码或图示
import json, orjson, msgspec
data = {"name": "Ann", "tags": ["backend", "python"]}
json.dumps(data) # str
orjson.dumps(data) # bytes
msgspec.encode(data) # 二进制
常见误区
- 只看序列化速度:反序列化、内存占用与类型校验同样要测。
- 把 ujson 当标准 json 等价替换:边界类型可能丢精度或抛错。
- 内部通信选 JSON 而忽略二进制 schema 方案:高频大消息有优化空间。
追问
- orjson 输出类型是什么?答:bytes,使用前按需 decode。
- msgspec 编码格式?答:基于 msgpack 风格的二进制,配合 Struct schema。
- 什么时候保留标准 json?答:类型兼容要求高、依赖受限或作为兜底。
04.7.20.1-040 orjson 有哪些输出与类型限制?
一句话结论
orjson 默认输出 UTF-8 字节串,速度快且不转义非 ASCII;它对可序列化类型有严格要求:日期/时间、UUID、字节等有专门支持,但自定义类、部分嵌套类型需要实现 default 回调,遇到不支持类型会抛 TypeError,而不是静默降级。
概念解释
- 输出 bytes:与标准库返回 str 不同,HTTP 响应可直接写入字节。
- 原生支持:
datetime/date/time、UUID、bytes/bytearray、numpy标量(待确认:验证点:当前版本支持的 numpy 类型范围)。 default=回调处理自定义对象,类似标准库的default。
原理流程
- 传入 dict/list 等原生结构或已标注类型对象。
- orjson 按类型规则编码,不支持类型交给
default。 - 输出字节串,需要文本时
.decode("utf-8")。 - 反序列化
orjson.loads接受 bytes/str/bytearray。
代码或图示
import orjson
from datetime import datetime
payload = {"ts": datetime(2026, 11, 19), "tags": ["a", "b"]}
raw = orjson.dumps(payload) # bytes
obj = orjson.loads(raw)
常见误区
- 拿 orjson 结果当 str 直接拼接:类型是 bytes,混用会报错。
- 自定义 dataclass 直接序列化:需配
default或转 dict。 - 假设与标准库输出逐字节一致:空白、转义、类型表示可能不同。
追问
- orjson 为什么返回 bytes?答:避免二次编码,便于直接写响应体。
- 不支持类型怎么处理?答:传
default回调转换为原生类型。 - 反序列化接受什么输入?答:bytes、str、bytearray 等。
04.7.20.1-041 ujson 有哪些兼容性坑?
一句话结论
ujson 以 C 实现换取速度,但在数值精度、嵌套深度、类型转换上与标准库 json 不完全等价:超大整数、浮点表示、特殊类型可能被截断或转成其他形式,替换前必须用边界用例比对,不能只跑 happy path。
概念解释
- 数值保真:大整数、极小/极大浮点的字符串表示可能与标准库不同。
- 类型宽松:某些非原生类型可能被强制转换,而标准库抛
TypeError。 - 嵌套深度与长度限制:极端结构下行为与标准库有差异(待确认:验证点:当前版本的深度/长度限制阈值)。
原理流程
- 用标准库与 ujson 分别序列化同一组边界数据。
- 比对输出文本、反序列化结果与类型。
- 记录不一致的类型与数值范围。
- 对外接口保持标准库行为,内部热点路径再评估 ujson。
代码或图示
import json, ujson
data = {"big": 10**40, "flag": None, "ratio": 0.1}
json.dumps(data)
ujson.dumps(data) # 边界数值表示需逐项核对
常见误区
- 全局替换
json = ujson:测试只覆盖普通字符串数字,边界问题上线后暴露。 - 依赖 ujson 抛出的异常类型做分支:异常类型与标准库不一致。
- 把 ujson 输出发给严格 JSON 解析器:非标准表示可能被对端拒绝。
追问
- ujson 主要风险在哪?答:数值与类型保真度弱于标准库。
- 替换前要做什么?答:边界用例双实现比对输出与反序列化结果。
- 什么场景不建议用 ujson?答:对外契约严格、数值精度敏感的接口。
04.7.20.1-042 msgspec 的 schema 化编码模型是什么?
一句话结论
msgspec 用 Python 类(Struct)声明字段与类型,encode/decode 在 schema 约束下完成二进制编码与对象还原;相比动态 dict 序列化,它在解码时即做类型检查,编码紧凑、速度快,适合内部高频 RPC 与消息队列载荷。
概念解释
Struct:字段带类型注解,可设默认值、可选字段。- 编码格式:msgpack 风格二进制,不是可读 JSON。
- 性能来源:C 扩展 + 静态 schema,减少运行时类型探测。
原理流程
- 定义继承
msgspec.Struct的消息结构。 msgspec.encode(msg)生成二进制,msgspec.decode(raw, Msg)还原对象。- 字段类型不符在解码阶段报错。
- 跨语言需配合对应 schema 或生成代码,不能只靠 Python 类。
代码或图示
import msgspec
class Order(msgspec.Struct):
order_id: str
amount: int
tags: list[str] = []
raw = msgspec.encode(Order("O-1", 100))
order = msgspec.decode(raw, Order)
常见误区
- 把 msgspec 当 JSON 替代品对外暴露:二进制格式对浏览器/外部调用方不友好。
- 字段演进不做兼容:新增必填字段会让旧消息解码失败。
- 忽略跨语言 schema:其他语言消费消息需要对应定义。
追问
- msgspec 解码时做什么?答:按 Struct 类型检查字段并还原对象。
- 编码是文本还是二进制?答:msgpack 风格二进制。
- 字段变更怎么保证兼容?答:新字段给默认值,避免破坏旧消息。
04.7.20.1-043 pickle 反序列化的安全边界在哪里?
一句话结论
pickle 只能反序列化完全可信的数据:解析过程会执行数据中携带的构造指令(__reduce__),不可信输入可触发任意代码执行。跨服务、跨语言、来自用户/消息队列/缓存的外部数据,禁止用 pickle,应改用 JSON、msgpack、protobuf 等数据格式。
概念解释
- pickle 是 Python 对象序列化协议,不是纯数据格式;载荷里可以包含可执行逻辑。
- 历史漏洞多通过构造恶意 pickle 触发
__reduce__调用危险函数。 - 即使加签名也不能把 pickle 变成安全格式:签名只防篡改,不防恶意构造。
原理流程
- 不可信字节流进入
pickle.loads。 - 解析器按协议重建对象,执行
__reduce__指定的调用。 - 恶意载荷借此执行系统命令或加载危险类。
- 安全边界:数据源必须是自己写入、未被篡改的内部存储。
代码或图示
import pickle
# 禁止:加载来自网络、用户、消息队列、第三方缓存的数据
# obj = pickle.loads(untrusted_bytes)
# 可信内部缓存场景也应评估替代方案
常见误区
- 给 pickle 加密/签名就对外使用:加密不改变可执行指令本质。
- 用 pickle 存跨语言消息:其他语言无法解析 Python 对象协议。
- 认为“数据不大就安全”:载荷大小与可执行风险无关。
追问
- pickle 为什么危险?答:反序列化会执行载荷中的构造指令,可任意代码执行。
- 哪些数据不能 pickle 加载?答:网络、用户、MQ、第三方缓存等不可信来源。
- 替代格式有哪些?答:JSON、msgpack、protobuf、msgspec 等纯数据格式。
04.7.20.1-044 pickle 协议版本与跨语言限制是什么?
一句话结论
pickle 协议版本由 protocol= 指定,高版本支持更多内建类型与更紧凑编码,但新旧 Python 版本之间要注意兼容;pickle 绑定 Python 对象模型,其他语言无法直接读取,也不适合作为长期存储格式,类结构变更后旧字节可能无法还原。
概念解释
- 协议版本:低版本兼容性好,高版本编码效率与类型支持更强(待确认:验证点:当前 Python 版本默认协议号)。
- 类引用:pickle 记录模块与类名,类被移动/删除后旧数据加载失败。
- 长期存储:结构演进、依赖变更都会破坏可还原能力。
原理流程
- 序列化时按协议号写入对象状态与类引用。
- 反序列化时按引用找到类,重建实例。
- 类路径变更或协议不匹配时抛出异常。
- 跨语言/长期持久化场景改用版本化数据格式。
代码或图示
import pickle
raw = pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
# 加载方 Python 版本与类结构必须匹配
常见误区
- 把 pickle 文件当长期归档:类改名/重构后无法读取。
- 不同 Python 大版本混用高协议:旧版本可能不识别。
- 在缓存里存 pickle 对象:缓存被污染后同样触发反序列化风险。
追问
- pickle 能被其他语言解析吗?答:不能直接解析 Python 对象协议。
- 类改名后旧 pickle 怎样?答:按引用找不到类,加载失败。
- 高协议版本一定更好吗?答:编码更紧凑,但要兼顾加载方版本兼容。
04.7.20.1-045 ensure_ascii 与中文编码怎么处理?
一句话结论
标准库 json.dumps(..., ensure_ascii=False) 直接输出 UTF-8 中文,默认 ensure_ascii=True 会把非 ASCII 转成 \uXXXX 转义;对外接口用 UTF-8 编码时通常关闭转义以减小体积,日志/调试保留转义也可,关键是编码在生成与消费两端一致。
概念解释
ensure_ascii=True:输出纯 ASCII,非 ASCII 转义,兼容性最广但体积大。ensure_ascii=False:保留 UTF-8 字符,体积小,需要下游按 UTF-8 解码。- 序列化结果是 str,写入响应/文件时再指定编码。
原理流程
- 确定下游编码约定(一般 UTF-8)。
- 选择
ensure_ascii取值,生成 JSON 字符串。 - 写入时按 UTF-8 编码为字节,响应头声明
charset=utf-8。 - 读取端按同一编码解码再
json.loads。
代码或图示
import json
payload = {"city": "楚雄", "tag": "后端"}
text = json.dumps(payload, ensure_ascii=False)
raw = text.encode("utf-8")
常见误区
- 序列化用 UTF-8 转义、读取端按 GBK 解码:中文乱码。
- 把 bytes 直接传给
json.loads:标准库可接受 bytes,但要确认编码。 - 接口响应头不声明 charset:客户端按默认编码解析出乱码。
追问
- ensure_ascii=False 省什么?答:减少
\uXXXX转义体积,保留原字符。 - 两端编码不一致会怎样?答:中文乱码或解析失败。
- orjson 默认怎么处理非 ASCII?答:直接输出 UTF-8 字节,不做 ASCII 转义。
04.7.20.1-046 序列化后如何搭配压缩?
一句话结论
文本 JSON 体积大、冗余高,可在序列化后用 gzip/deflate/zstd 压缩传输或落盘;压缩是 CPU 换体积,要在“报文大小、压缩耗时、解压耗时”之间权衡,大消息与高频消息才值得压,小请求压缩收益有限反而增加延迟。
概念解释
- 压缩层级:级别越高压缩率越好,CPU 耗时越大。
- 流式压缩:大对象可以边序列化边压缩,避免整段进内存。
- 传输层压缩(HTTP
Content-Encoding)与应用层压缩是两层,不要重复压。
原理流程
- 评估消息大小与频率,判断压缩收益。
- 序列化得到文本/二进制载荷。
- 选择压缩算法与级别,压缩后落盘或发送。
- 消费端先解压再反序列化,错误处理区分解压失败与格式错误。
代码或图示
import gzip, json, zstandard as zstd
payload = {"items": list(range(1000))}
raw = json.dumps(payload).encode("utf-8")
compressed = gzip.compress(raw, compresslevel=6)
restored = json.loads(gzip.decompress(compressed))
常见误区
- 已经在 HTTP 层开 gzip,应用层再压一次:双重压缩浪费 CPU。
- 小消息强行压缩:压缩头开销抵消收益,延迟上升。
- 不记录压缩格式:解压端无法选择正确算法。
追问
- 压缩主要代价是什么?答:CPU 时间,压缩/解压都耗计算。
- 大对象怎么避免内存峰值?答:边序列化边流式压缩写入。
- 哪些算法常见?答:gzip、deflate、zstd(待确认:验证点:项目环境可用的算法与依赖)。
04.7.20.1-047 NaN/Infinity 在标准 JSON 里是什么边界?
一句话结论
标准 JSON 规范只允许有限数值,NaN、Infinity、-Infinity 不是合法 JSON 标记;Python 标准库 json 出于兼容会输出这些裸标记,但严格解析器(其他语言、浏览器 JSON.parse)会拒绝,对外接口必须在序列化前把它们转换为 null 或有限值。
概念解释
- 标准库行为:
json.dumps(float("nan"))输出NaN,属于 Python 扩展写法。 - 严格解析:
JSON.parse、多数语言 JSON 库遇到裸NaN报错。 - 来源:除法零、缺失计算、浮点溢出、未初始化数值。
原理流程
- 序列化前扫描数值字段,识别非有限浮点。
- 按业务约定转为
null、0 或显式错误标记。 - 输出严格合法 JSON,下游可无歧义解析。
- 日志记录非法数值来源,避免掩盖计算问题。
代码或图示
import math, json
def clean(v):
if isinstance(v, float) and not math.isfinite(v):
return None
return v
payload = {"ratio": clean(float("inf"))}
json.dumps(payload, ensure_ascii=False)
常见误区
- 认为 Python 能 round-trip 就代表 JSON 合法:外部严格解析器不接受。
- 把 NaN 当 0 静默处理:掩盖了上游计算错误。
- 接口文档不说明缺失值表示:调用方无法区分 null 与 0。
追问
- NaN 是合法 JSON 吗?答:不是,标准 JSON 只允许有限数值。
- 标准库为什么能输出 NaN?答:历史兼容的 Python 扩展写法。
- 对外接口怎么处理?答:序列化前转 null 或有限值,并记录来源。
04.7.20.1-048 日期时间与 Decimal 怎么序列化?
一句话结论
JSON 没有日期与高精度十进制原生类型,惯例用 ISO 8601 字符串表示时间,Decimal 转字符串或浮点需按精度约定;时间统一存 UTC,展示层再转本地时区,避免序列化端携带歧义时区。
概念解释
- 时间:
datetime.isoformat()生成 ISO 8601,带时区偏移;naive 时间要先补时区。 Decimal:转str保留精度,转float会引入二进制浮点误差。- 下游解析端按格式还原,类型约定写进接口文档。
原理流程
- 时间对象转 UTC 并生成 ISO 字符串。
- Decimal 按约定序列化为字符串(高精度金额)或数值。
- 反序列化时按字段类型还原为
datetime/Decimal。 - 跨时区展示在应用层完成,不把本地时间塞进载荷。
代码或图示
from datetime import datetime, timezone
from decimal import Decimal
import json
now = datetime.now(timezone.utc)
amount = Decimal("19.99")
payload = {"ts": now.isoformat(), "amount": str(amount)}
json.dumps(payload, ensure_ascii=False)
常见误区
- 时间序列化为时间戳又混用字符串:同一字段两种格式,解析端出错。
- Decimal 转 float 存金额:分位精度丢失。
- 序列化本地 naive 时间:跨时区接收方无法判断原始时刻。
追问
- 时间推荐什么格式?答:UTC 的 ISO 8601 字符串。
- Decimal 为什么用字符串?答:避免 float 二进制误差,保留十进制精度。
- 时区转换在哪层做?答:展示层,载荷统一 UTC。
04.7.20.1-049 大体积 JSON 怎么流式解析?
一句话结论
整段 json.loads 会把完整对象与字节流同时留在内存,大文件/大响应需要流式解析:按读取位置逐个产出事件或记录(如 JSON 数组逐条对象),解析一条处理一条,内存与文件大小解耦。标准库本身不提供完整流式 API,需借助事件式解析库或分块预处理。
概念解释
- 整段解析:内存 ≈ 文件大小 × 2(字节 + 对象)。
- 事件流解析:回调在遇到键、值、数组元素时触发,上层只保留当前记录。
- 适用场景:日志导出、批量导入、大报表解析。
原理流程
- 打开文件/响应流,按块读取。
- 流式解析器维护状态机,产出 token 或完整记录。
- 上层逐条处理(落库、转换、转发),不保留全量对象。
- 处理完一条即释放引用,控制内存峰值。
代码或图示
# 事件式流式解析思路(具体库按环境选型)
# 逐条取出数组中的对象,处理后释放
# with open("big.json", "rb") as f:
# for record in iter_records(f):
# process(record)
常见误区
- 大文件先
read()再 loads:字节串与对象双重占用内存。 - 流式解析器状态处理不当:跨块的字符串被截断。
- 一次性把解析结果收进 list:流式只省了解析中间态,结果堆积仍 OOM。
追问
- 标准库支持流式解析吗?答:没有完整事件式 API,需选第三方解析库(待确认:验证点:当前环境可用的流式 JSON 库)。
- 流式后内存由什么决定?答:单条记录大小与并发处理量。
- 什么数据适合流式?答:大数组日志、批量导入、分页导出。
04.7.20.1-050 字节字段在 JSON 中如何表示?
一句话结论
JSON 没有二进制类型,字节字段通常用 Base64 编码成字符串传输;编码后体积膨胀约三分之一,且两端要约定编码方式。大二进制数据(图片、文件)不应塞进 JSON 载荷,应走对象存储或分片上传,JSON 里只放引用地址。
概念解释
- Base64:把字节映射为可打印 ASCII,是 JSON 内嵌二进制的通用约定。
- 体积膨胀:每 3 字节编码为 4 字符,约 +33%。
- 替代方案:二进制协议(msgpack/protobuf)原生支持 bytes,避免 Base64。
原理流程
- 判断字段是否必须内嵌二进制;能给 URL 就给 URL。
- 必须内嵌时对字节做 Base64 编码为字符串。
- 序列化进 JSON,消费端先 Base64 解码再用字节。
- 接口文档标注编码方式与字节长度。
代码或图示
import base64, json
raw = b"\x89PNG\r\n"
payload = {"image_b64": base64.b64encode(raw).decode("ascii")}
text = json.dumps(payload)
decoded = base64.b64decode(json.loads(text)["image_b64"])
常见误区
- 直接把 bytes 丢给标准 json:抛
TypeError。 - 大文件 Base64 内嵌:报文膨胀且解析内存高。
- 两端编码不一致(Base64 变体/URL-safe):解码失败或损坏。
追问
- JSON 能直接放二进制吗?答:不能,需 Base64 等文本编码。
- Base64 膨胀多少?答:约三分之一(3 字节变 4 字符)。
- 大二进制推荐怎么传?答:对象存储/分片上传,JSON 放引用地址。
04.7.20.1-051 如何定位序列化在服务端的 CPU 占比?
一句话结论
先用采样剖析(cProfile/line_profiler 或线上持续剖析)区分时间花在网络等待、业务计算还是 JSON 编解码;序列化热点通常表现为 json.dumps/loads、orjson 编码函数占 CPU 比例高,再结合报文大小与 QPS 估算每秒序列化字节量,决定是否换更快的库或减小载荷。
概念解释
- 剖析要区分 CPU 时间与 wall time:网络等待不计入 CPU 热点。
- 大报文 + 高 QPS 是序列化成本放大器:单条耗时 × 并发量。
- 优化顺序:先减字段/减体积,再换编码库,最后才考虑二进制协议。
原理流程
- 在压测或线上采样剖析,按函数聚合 CPU 占比。
- 确认编解码函数是否进入热点前列。
- 统计平均报文大小、QPS,估算序列化吞吐。
- 对比候选库在同等数据上的耗时与内存,小范围灰度验证。
代码或图示
import cProfile, pstats
profiler = cProfile.Profile()
profiler.enable()
# 执行业务请求
profiler.disable()
pstats.Stats(profiler).sort_stats("cumulative").print_stats(20)
常见误区
- 用单次本地调用判断库快慢:未考虑并发、内存分配与 GC 压力。
- 只优化序列化不看载荷:冗余字段去掉后编码自然变快。
- 剖析结果把 IO 等待误判为 CPU 热点:先分离等待与计算。
追问
- 序列化热点怎么识别?答:编解码函数在 CPU 剖析中占比靠前。
- 优化顺序是什么?答:减字段减体积 → 换编码库 → 评估二进制协议。
- 为什么要统计报文大小?答:单条耗时乘大小与 QPS 才是真实成本。
04.7.20.1-052 JSON 缺少 schema 会带来什么问题?
一句话结论
动态 JSON 没有字段类型与必填约束,字段缺失、类型错、命名漂移只能在运行时暴露;接口契约靠文档口头约定,前后端/多语言协作成本高。关键链路应引入 schema 校验(Pydantic/marshmallow)或契约定义,在入口处拒绝不合规数据。
概念解释
- 无 schema:解析出 dict,取值靠键名约定,错键不报错。
- 运行时才发现:下游取
data["amount"]遇到缺失或字符串,异常沿调用链扩散。 - 契约漂移:字段改名/改类型,调用方与提供方不同步。
原理流程
- 入口接收原始 JSON,先按 schema 校验类型与必填。
- 校验失败返回明确错误,不进入业务逻辑。
- 校验通过后得到类型安全的对象,业务直接使用。
- 契约变更通过 schema/接口文档同步给调用方。
代码或图示
# 无 schema:错键、缺字段都要到使用时才爆
data = response.json()
amount = data["amount"]
# 有 schema:入口即校验(示例为思路,具体库见 04.7.20.3)
常见误区
- 信任内部服务返回:内部接口同样会变更,缺字段会打垮调用方。
- 在每个取值点重复判空:应在入口统一校验,而不是散落防御。
- schema 只用于请求不用于响应:下游消费响应同样需要类型保障。
追问
- 无 schema 最大风险是什么?答:错误延迟到运行时业务路径才暴露。
- 校验放在哪一层?答:接口入口,解析后、业务处理前。
- 契约漂移怎么治理?答:schema/接口文档 + 版本化变更通知。
04.7.20.1-053 序列化版本兼容怎么做?
一句话结论
跨版本消息要做到“新增字段可选、删除字段容忍、类型不随意改”:消费端忽略未知字段,生产端不给必填字段强约束;格式本身版本化(schema 版本号、协议字段编号),破坏性变更走新接口或新版本,而不是原地改老契约。
概念解释
- 向前兼容:新生产端发旧消费端,旧端忽略未知字段。
- 向后兼容:旧生产端发新消费端,新端对缺失字段给默认值。
- 破坏性变更:改字段类型、改语义、删除必填字段,需要版本隔离。
原理流程
- 定义 schema 时区分必填与可选,新字段一律可选。
- 消费端解析时容忍未知字段与缺失可选字段。
- 字段语义/类型变更先评估兼容,必要时开新版本。
- 消息或接口携带版本标识,便于灰度与回滚。
代码或图示
兼容:新增可选字段、字段改名并存过渡期
破坏:改类型、改语义、删除必填字段 → 新版本/新接口
常见误区
- 直接在老字段上改类型:旧消费端解析失败。
- 消费端严格拒绝未知字段:生产端加字段就把旧端打挂。
- 消息不记版本:出问题无法定位是哪一版契约。
追问
- 什么是向前/向后兼容?答:新端旧端互发消息都能解析。
- 新增字段要注意什么?答:设为可选,旧端可忽略。
- 破坏性变更怎么处理?答:版本隔离,不走原地修改。
04.7.20.1-054 客户端封装应统一哪些横切能力?
一句话结论
内部封装一层 HTTP 客户端,统一超时、连接池、重试与幂等判断、请求/响应日志与指标、错误归一化、认证头注入与代理配置;业务代码只传 URL、参数与业务预期,避免每个调用处重复造轮子并漏配超时。
概念解释
- 横切能力:与具体业务无关、所有下游调用都需要的策略。
- 封装边界:底层客户端可替换(requests/httpx/aiohttp),上层方法接口稳定。
- 可观测性:统一记录耗时、状态码、异常类型、下游标识,便于排障。
原理流程
- 初始化长生命周期客户端,配置默认超时与池参数。
- 封装
get/post等方法,注入认证与默认头。 - 统一执行重试策略(仅限幂等方法)与异常转换。
- 输出结构化日志与指标,业务层处理归一化后的错误类型。
代码或图示
import httpx
class DownstreamClient:
def __init__(self):
self._client = httpx.Client(timeout=httpx.Timeout(connect=3, read=10))
def get(self, url, **kwargs):
resp = self._client.get(url, **kwargs)
resp.raise_for_status()
return resp.json()
常见误区
- 封装层把底层类型直接暴露:后续换库影响所有调用方。
- 每个方法各自配超时/重试:策略不一致,漏配一处就出事故。
- 日志打印完整请求体/凭证:敏感信息泄漏,需脱敏。
追问
- 封装层必须统一什么?答:超时、连接池、重试、日志指标、认证与错误归一化。
- 为什么底层要可替换?答:业务接口稳定,库选型可后续调整。
- 日志要注意什么?答:脱敏凭证与敏感字段,不打印完整载荷。
04.7.20.1-055 HTTP 客户端选型怎么总结?
一句话结论
存量同步栈、简单脚本用 requests;需要异步、HTTP/2、测试 mock 或同步异步统一 API 用 httpx;已有 aiohttp 服务端生态或细粒度连接器调优用 aiohttp。三者共性要求一致:长生命周期复用连接、显式分级超时、按幂等性决定重试、流式处理大响应、生产关闭证书校验。
概念解释
- requests:生态最广、资料最多,同步场景默认选择。
- httpx:双 API、异步原生、传输层可替换,新服务优先评估。
- aiohttp:异步客户端+服务端一体,连接器配置细。
- 选型不改变工程底线:超时、池、重试、流式、安全校验缺一不可。
原理流程
- 按运行模型(同步/异步)与既有栈缩小范围。
- 核对协议需求(HTTP/2)、测试方式、代理与证书配置。
- 小压测验证连接复用与错误分支行为。
- 通过封装层隔离底层,保留后续替换空间。
代码或图示
同步脚本/存量服务 → requests
异步服务、双栈统一、可测试传输 → httpx
aiohttp 同生态、细粒度连接器 → aiohttp
常见误区
- 追新盲目换库:团队不熟悉、踩坑成本高于收益。
- 选型后忽略工程配置:换了库仍不设超时,事故照旧。
- 把客户端库当服务治理:重试/熔断/限流还需要框架或中间件配合。
追问
- requests 适合什么场景?答:同步脚本、存量服务、生态依赖广的项目。
- httpx 的核心优势?答:异步原生、双 API、HTTP/2、可替换传输。
- 无论选哪个都必须做什么?答:复用连接、分级超时、幂等重试、流式与证书校验。
本节高频题
- requests 默认无超时的危害(001、002)
- Session 连接复用与 Cookie(003)
- HTTPAdapter 连接池参数(004)
- urllib3.Retry 策略与挂载重试(005、006)
- SSL 校验与异常(007、018)
- stream=True 与流式下载(008、009、023)
- 重试的幂等前提(014)
- 连接池耗尽与调优(015)
- httpx 同步/异步与生命周期(025、026)
- Limits 与分级超时(027、029)
- HTTP/2 启用条件(028)
- aiohttp 会话与连接器(034、035、036)
- 序列化库性能与兼容取舍(039、040、041)
- pickle 安全边界(043、044)
- NaN/Decimal/时间序列化边界(047、048)
- 客户端统一封装(054)