跳到正文
零到全栈 · 卷 8 · 从作品到产品

性能与缓存

本合集目录
本章目录

单册说明:本文件是卷 8 的第 3 章,可独立阅读。前置:第 2 章(测试锁住主线)。本章先教你怎么量出三个数,再按"传输体积 → 数据库 → 渲染"的顺序优化。不换框架、不加机器。

项 内容
所属卷 卷 8 · 从作品到产品(第 3 / 6 章)
前置章节 8.2 测试三层
本章产出 一份改前/改后的数字对比(TTFB、P95、传输字节、查询耗时)+ 一份 Nginx 缓存与压缩配置
对应代码 scripts/bench.sh(curl 多次取样算 P95)、curl-format.txt、Nginx 片段
配图 无(后续统一制图)
读完的判定 能说出"慢在哪一段",并用一条命令验证优化是否真的生效

8.3.1 一句话结论:没有测量,优化就是换一种方式浪费时间

你的首页要 4.8 秒才出来。第一反应是"Next.js 太重,换个框架",于是花两周重写,变成 4.2 秒。

真实原因通常无聊得多:接口返回 180 KB 未压缩的 JSON(列表把每条摘录的全文都带上了)、notes 表 5 万行每次查询全表扫、首屏那张 2.4 MB 的 PNG 没有指定尺寸。三处加起来占了 4 秒里的 3.6 秒,和框架没有关系。

一句话结论:先定三个数——接口 TTFB、首屏时间、接口 P95——再决定动哪里;改完用同一条命令复测,数字没变就是白干。

性能优化最容易犯的错不是"用了错的方法",是"没量就动手":凭感觉换框架、凭感觉加缓存、凭感觉买服务器,每一项都要花掉几天,却没有一项能证明有效。

8.3.2 原理与方法

三个指标:够用,且都能自己取

指标 定义 怎么取 个人站的及格线
TTFB 从发出请求到收到第一个字节 curl -w '%{time_starttransfer}' 动态接口 < 200 ms
首屏 用户看到主要内容的时间(LCP) 浏览器 Performance 面板 / Lighthouse < 2.5 s
接口 P95 95% 的请求都在这个时间内完成 采样 20 次排序取第 19 个,或读 Nginx 日志 < 300 ms

只看平均值会被少数慢请求骗过去:19 次 50 ms、1 次 3 秒,平均 197 ms 看着还行,但那 1 次就是用户骂"卡"的时刻。P95 才是体感。

时间花在哪:先归因,再动手

一次请求的耗时可以拆成五段,每段的对策完全不同:

段落 典型占比(个人站) 优化手段 改完能省多少
DNS + TCP + TLS 10–20% keep-alive、HTTP/2、减少域名跳转 几十到几百毫秒
服务器处理(应用 + SQL) 20–40% 索引、去掉 N+1、减少序列化字段 常常是一半以上
传输体积 20–40% gzip/brotli、只传需要的字段、图片压缩 70–90% 的字节
浏览器解析与执行 10–30% 代码分割、懒加载、减少第三方脚本 几百毫秒到数秒
渲染与布局 5–10% 图片定尺寸、字体 font-display 减少抖动,不减少总时长

先看传输体积,是因为它最容易量、最容易降。 一个 curl 加两个响应头就能确认有没有压缩。

按"收益 ÷ 成本"排序,「读到」的优化顺序应该是:

顺序 动作 典型收益 上手成本
1 开 gzip 文本字节降 70–90% 10 分钟
2 列表只传需要的字段 响应体降 50–80% 半小时
3 建联合索引 单查询快 10–100 倍 20 分钟
4 图片转格式 + 定尺寸 图片字节降 60–80% 1 小时
5 路由分割 + 动态导入 首屏少 200–500 ms 半天
6 换框架 / 换数据库 不确定,常常接近 0 两周以上

这张表解释了一个反直觉的事实:排在前四位的动作加起来不到两小时,却通常能拿走大部分收益。先做完这四件,再讨论要不要动架构。

gzip 与 brotli:先开 gzip,再谈 brotli

文本类响应(HTML、CSS、JS、JSON、SVG)压缩率通常在 70–90%,图片和 woff2 本身已压缩,再压可能变大。

内容 原始 gzip 后 说明
列表接口 JSON 180 KB 24 KB 字段重复度高,压缩率最好
首页 HTML 42 KB 9 KB
主 JS bundle 310 KB 96 KB
PNG 截图 2.4 MB 2.4 MB 不该压,该换格式和尺寸

Nginx 开 gzip 的最小配置:

gzip on;
gzip_comp_level 5;
gzip_min_length 1024;
gzip_vary on;
gzip_types text/plain text/css application/javascript application/json application/xml image/svg+xml;

三个参数的理由:comp_level 5 是压缩率与 CPU 的平衡点(9 只多压 3%,CPU 翻倍);min_length 1024 避免给小响应加压缩头反而变大;gzip_vary on 让缓存知道"同一个 URL 有压缩和未压缩两份"。

text/html 不需要写进 gzip_types——Nginx 默认就压它。很多人配完发现 HTML 压了、JSON 没压,就是漏了 application/json。

brotli(新一代压缩算法)比 gzip 再小 10–15%,但需要额外模块(多数系统包不自带),还要为静态资源预压缩。它的优先级在"索引、N+1、图片"之后,不是第一件事。

缓存头:三类资源,三种策略

缓存配错比不配更危险:用户会看到别人的数据,或者永远看不到更新。

资源 响应头 理由
带哈希名的静态资源(/_next/static/...) public, max-age=31536000, immutable 文件名变了内容才变,可以缓存一年
HTML 页面 no-cache 可以存,但每次要回源确认,保证能拿到新版本
接口 /api/* no-store 含用户私有数据,任何中间层都不能存
location /_next/static/ {
    add_header Cache-Control "public, max-age=31536000, immutable";
}

location / {
    add_header Cache-Control "no-cache";
}

location /api/ {
    add_header Cache-Control "no-store";
}

⚠️ location 里一旦出现 add_header,会覆盖从 server 继承来的所有头。第 4 章的安全头如果配在 server 层,这三个 location 会让它们全部消失。稳妥做法是把安全头抽成 include security-headers.conf;,在每个 location 里重复引用一次。

immutable 的意思是"在这一年内,别再来问服务器这个文件变没变"。它只对文件名带内容哈希的资源成立;如果你的 JS 叫 main.js,加 immutable 等于让用户一年看不到更新。

图片:三件小事,收益最大

动作 怎么做 收益
尺寸对 显示 360 px 宽就传 720 px(2 倍图),不要传 2400 px 体积降一个数量级
格式对 截图转 WebP,照片用 AVIF/WebP 比 PNG 小 60–80%
懒加载 <img loading="lazy" width="800" height="450"> 首屏只加载可见图片,且不抖动

width 和 height 必须写。它们不是为了好看,是让浏览器在图片下载前就预留空间,避免内容跳动(CLS)。用 Next 的 <Image> 时,宽高或 fill 二选一,别都不给。

传输体积:先砍字段,再谈压缩

列表接口最常见的浪费是 SELECT * 然后把整行序列化。20 条摘录、每条正文 8 KB,就是 160 KB;而列表页真正显示的只有标题、时间和一行摘要。

字段 列表需要 处理
id 是 用于跳转详情
title 是 直接显示
content 否(只要摘要) substr(content, 1, 80)
source_url 否 详情页再取
created_at 是 排序与显示
SELECT id, title, substr(content, 1, 80) AS excerpt, created_at
FROM notes
WHERE user_id = ?
ORDER BY created_at DESC
LIMIT 20;

同一个接口,响应从 180 KB 降到 24 KB,再经过 gzip 只剩 6 KB。这比任何缓存都直接:数据根本没发出去,就没有缓存和过期的问题。

索引与 N+1:数据库的两笔常见账

索引:「读到」的列表查询是

SELECT id, title, created_at FROM notes
WHERE user_id = ? ORDER BY created_at DESC LIMIT 20;

没有索引时,SQLite 会扫全表再排序。EXPLAIN QUERY PLAN 显示 SCAN notes + USE TEMP B-TREE FOR ORDER BY;加上

CREATE INDEX IF NOT EXISTS idx_notes_user_created
ON notes(user_id, created_at DESC);

之后变成 SEARCH notes USING INDEX idx_notes_user_created (user_id=?)。顺序不能反:等值条件(user_id)在前,排序字段在后,这样索引既能定位又能直接按序取,省掉排序。

在一台普通笔记本、5 万行数据的库上实测(形如,你的数字会不同,看数量级):

状态 执行计划 单次查询
无索引 SCAN notes + 临时 B 树排序 25–38 ms
有联合索引 SEARCH ... USING INDEX 0.2–0.8 ms

N+1:列表页有 20 条摘录,每条再查一次标签,就是 1 + 20 = 21 次查询。单次 1 ms 看着不慢,21 次加上网络/解析就是 40 ms,条目越多越糟。改成一条 JOIN:

SELECT n.id, n.title, n.created_at, GROUP_CONCAT(t.name, ',') AS tags
FROM notes n
LEFT JOIN note_tags nt ON nt.note_id = n.id
LEFT JOIN tags t ON t.id = nt.tag_id
WHERE n.user_id = ?
GROUP BY n.id
ORDER BY n.created_at DESC
LIMIT 20;

注意 GROUP_CONCAT 的结果是一个字符串,返回给前端时要 split(',');没有标签时是 NULL,要转成空数组。

前端:懒加载与代码分割

手段 用在「读到」的哪里 效果
路由级分割 Next 默认按页面拆分 首屏不加载"设置页"的代码
动态导入 富文本编辑器、图表库 首屏少 100–300 KB
图片懒加载 列表里的封面 首屏只下载可见的几张
第三方脚本延后 统计脚本加 defer 不阻塞 HTML 解析

原则只有一条:首屏不需要的,就不要在首屏加载。 编辑器只有点"新建"才出现,那它就不该进入首屏 bundle。

SQLite 什么时候会成为瓶颈

SQLite 不是"玩具",个人站到几千用户都够用。但出现下面任一信号,就该计划迁移:

信号 具体判断 原因
持续写入 稳定超过 20–50 次/秒 写锁是库级的,写入串行
写等待 日志里频繁出现 database is locked 并发写冲突,busy_timeout 也救不了高并发
库大小 超过 5 GB 备份、恢复、迁移的时间不可接受
多机部署 两台以上应用要同时写 SQLite 是单机文件,没法共享写
长事务 单事务超过 1 秒 期间其他写全部阻塞

在迁移之前,先做两件事,往往能把瓶颈推后很久:

PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;
PRAGMA busy_timeout = 5000;

WAL(预写日志)让读不阻塞写、写不阻塞读,但写与写仍然串行——它解决的是"读被写卡住",不是"写入能力不足"。这个区别值得记牢,否则会以为开了 WAL 就能扛高并发写。

8.3.3 动手:量一次,改一次,再量一次

第一步:单次请求拆解

把格式串存成 curl-format.txt:

dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total} size=%{size_download}\n
curl -s -o /dev/null -w @curl-format.txt https://dudao.example.com/api/notes

输出形如:

dns=0.012 tcp=0.031 tls=0.078 ttfb=0.164 total=0.171 size=184320

读法:ttfb - tls 是服务器处理时间(约 86 ms),total - ttfb 是传输时间(约 7 ms),size 是字节数。如果 size 很大而 total 很小,说明本地网络快,但真实用户的移动网络会被这 180 KB 拖住。

第二步:采样算 P95

#!/usr/bin/env bash
set -euo pipefail

url="${1:?用法: ./bench.sh <url> [次数]}"
count="${2:-20}"

for _ in $(seq 1 "$count"); do
  curl -s -o /dev/null -w '%{time_total}\n' "$url"
done | sort -n | awk '
  { t[NR] = $1 }
  END {
    n = NR
    p50 = int((n + 1) * 0.5); if (p50 < 1) p50 = 1
    p95 = int((n + 1) * 0.95); if (p95 > n) p95 = n
    printf "n=%d  p50=%.3fs  p95=%.3fs  max=%.3fs\n", n, t[p50], t[p95], t[n]
  }'
chmod +x scripts/bench.sh
./scripts/bench.sh https://dudao.example.com/api/notes 20

输出形如:

n=20  p50=0.181s  p95=0.402s  max=0.917s

改完再跑同一条命令,p95 从 0.402 降到 0.09 才算有效。别用"感觉快了"当结论。

自己机器上的 20 次采样只能看趋势,真实用户要看日志。先在 Nginx 的 log_format 末尾加上 $request_time:

log_format main '$remote_addr [$time_local] "$request" $status '
                '$body_bytes_sent "$http_referer" $request_time';

再用一条命令从当天日志里取分位:

awk '{print $NF}' /var/log/nginx/access.log | sort -n | awk '
  { t[NR] = $1 }
  END {
    n = NR
    printf "n=%d  p50=%.3fs  p95=%.3fs\n", n, t[int((n + 1) * 0.5)], t[int((n + 1) * 0.95)]
  }'

它和 bench.sh 算的是同一件事,区别是样本来自真实网络和真实设备。如果日志里的 P95 比你本地高一个数量级,问题多半在传输体积或移动网络,而不是服务器 CPU。

什么时候停:三个指标达标(TTFB < 200 ms、P95 < 300 ms、首屏 < 2.5 s)就停手。继续追 Lighthouse 满分,往往要引入预连接、临界 CSS、字体子集化等一堆构建配置,维护成本远大于收益。个人站的性能目标是"不让人等",不是"跑分第一"。

第三步:量压缩前后的字节

# 不声明支持压缩
curl -s -o /dev/null -w 'raw=%{size_download}\n' https://dudao.example.com/api/notes

# 声明支持 gzip
curl -s -o /dev/null -w 'gzip=%{size_download}\n' \
  -H 'Accept-Encoding: gzip' https://dudao.example.com/api/notes

# 确认响应头
curl -sI -H 'Accept-Encoding: gzip' https://dudao.example.com/api/notes | grep -i content-encoding

形如 raw=184320 / gzip=24118,约 87% 的降幅。如果两个数字一样,说明 Nginx 没压这个类型,回去检查 gzip_types 里有没有 application/json。

第四步:索引前后各测一次

sqlite3 data/dudao.db "EXPLAIN QUERY PLAN SELECT id FROM notes WHERE user_id=1 ORDER BY created_at DESC LIMIT 20;"

看到 SCAN notes 就加索引,再跑一次,应看到 SEARCH ... USING INDEX:

CREATE INDEX IF NOT EXISTS idx_notes_user_created ON notes(user_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_note_tags_tag ON note_tags(tag_id, note_id);
ANALYZE;

索引不是越多越好:每个索引都会让写入多一次维护。只给"WHERE 等值列 + ORDER BY 列"建联合索引,并且用 EXPLAIN 确认它真的被用上。

第五步:确认缓存头

curl -sI https://dudao.example.com/_next/static/chunks/main-abc123.js | grep -i cache-control
curl -sI https://dudao.example.com/api/notes | grep -i cache-control

期望分别是 public, max-age=31536000, immutable 和 no-store。如果接口返回了 max-age=600,那不是优化,是事故——下一个用户可能看到上一个用户的列表。

8.3.4 三个坑

坑 1:给 API 加了长缓存

症状:退出登录后刷新,仍能看到上一个账号的摘录;或者在共用电脑上,B 登录后看到 A 的数据。 成因:为了让"列表加载快",给 /api/notes 加了 Cache-Control: max-age=600,浏览器直接命中本地缓存,请求根本没发出去。 修法:接口一律 no-store;要提速就压体积、加索引、减少字段,不要缓存在客户端。只有"与用户无关"的接口(比如公开的标签云)才可以短缓存。

坑 2:只压了 HTML,没压 JSON

症状:首页加载快了,但列表要转两秒;curl 看 HTML 有 Content-Encoding: gzip,接口没有。 成因:Nginx 默认只压 text/html,application/json 必须显式写进 gzip_types。 修法:把 application/json、application/javascript、image/svg+xml 都加上;改完用 curl -H 'Accept-Encoding: gzip' 对比字节数确认。

坑 3:索引加错列,查询反而更慢

症状:给 user_id 单独建了索引,EXPLAIN 仍然显示 SCAN;写入还慢了。 成因:查询同时带 WHERE user_id = ? 和 ORDER BY created_at DESC,单列索引能过滤但不能排序,SQLite 判断"不如全表扫 + 排序"。 修法:建联合索引 (user_id, created_at DESC),等值列在前、排序列在后;用 EXPLAIN QUERY PLAN 验证出现 SEARCH ... USING INDEX,再对比 p95。

本章验收

  • 能用一个 curl -w 命令拆出 DNS / TLS / TTFB / 总时长 / 字节数
  • 有一份改前基线:接口 P95、首页 LCP、列表 JSON 字节数
  • gzip 已开,且 application/json 在 gzip_types 里(用响应头验证过)
  • 静态资源 immutable、HTML no-cache、接口 no-store,三者都用 curl -I 确认
  • notes 查询从 SCAN 变成 SEARCH ... USING INDEX,并记录了前后耗时
  • 能说出 SQLite 变成瓶颈的三个具体信号

自测

Q1:平均值 200 ms、P95 900 ms,说明什么?该先查哪里?

看答案 说明大多数请求很快,但有约 5% 的请求慢了 4 倍以上。常见原因是:缺少索引导致部分用户(数据量大)查询变慢、连接池/写锁偶发等待、或某个外部调用超时重试。先按用户维度看日志,确认慢请求是否集中在"摘录多"的账号上;如果是,优先查 SQL 计划。

Q2:为什么 Cache-Control: immutable 只能给带哈希文件名的资源?

看答案 因为 `immutable` 告诉浏览器"这一年里不要再来问",浏览器会完全跳过校验。如果文件名固定(如 `main.js`),你发布新版本后,老用户一年内都拿不到新代码。带内容哈希的文件名(如 `main-a1b2c3.js`)内容一变名字就变,旧文件自然不再被引用,才可以安全地长期缓存。

Q3:开了 WAL,SQLite 能不能扛住每秒 200 次写入?

看答案 不能。WAL 改善的是"读不被写阻塞",写与写之间仍然是串行的,同一时刻只有一个写事务。每秒 200 次持续写入会频繁触发 `database is locked` 或排队。这种量级要么把写合并成批量事务,要么换支持并发写的数据库。

下一步

快了之后要问一句"快得安全吗"。下一章按十类风险逐条对照,先修最贵的两个:越权和 XSS。

→ 卷8-04-安全清单.md