用处
gzip 用于压缩数据,节省传输时的带宽和传输时间。
HTML / JS / CSS / JSON / SVG / XML 用 gzip 收益较大; 不过 gzip 不适合已压缩数据(图片/视频/woff2)。
原理
gzip 的压缩核心是 DEFLATE 算法(RFC 1951)。
DEFLATE 分两步:LZ77 负责找重复串,把 (长度, 距离) 作为 token 输出;哈夫曼负责给这些 token 分配变长码。
例子:
原文
function toggleFavorite(comicId){this.comics[comicId].favorite=!this.comics[comicId].favorite}
LZ77
经过 LZ77 之后变成一个token数组
token数组和token都不是官方的说法,我这样说是为了便于理解,将
LIT 's'和MATCH [len=5 dist=14]看作一个类(token),整个输出看作这个类的数组
1-38. LIT 'f' 'u' 'n' 'c' 't' 'i' 'o' 'n' ' ' ... 't' 'h' 'i' 's' '.'
39. MATCH [len=5 dist=14]
40. LIT 's'
41. LIT '['
42. MATCH [len=7 dist=21]
43-45. LIT ']' '.' 'f'
46. MATCH [len=7 dist=39]
47-48. LIT '=' '!'
49. MATCH [len=29 dist=31]
50. LIT '}'
1-38 是我省略的写法,序号也是为了方便理解加上的,实际上没有这些序号
拆分与替换
再对MATCH进行拆分与替换,把 len 和 dist 分别换成 长度码 和 距离码。
MATCH [len=5 dist=14] → MATCH( 长度码 259 · 距离码 7 + 偏移 01 )
- 长度码代表一个长度区间,区间起点 + 偏移 = 实际的 len
- 距离码同理
拆分替换之后的输出
[1] 字面量码 102 'f'
[2] 字面量码 117 'u'
[3] 字面量码 110 'n'
... (共 38 项)
[38] 字面量码 46 '.'
[39] 长度码 259 ← 长度 5,无偏移
[40] 距离码 7 + 偏移 01 ← 距离 14
[41] 字面量码 115 's'
[42] 字面量码 91 '['
[43] 长度码 261 ← 长度 7
[44] 距离码 8 + 偏移 100 ← 距离 21
[45] 字面量码 93 ']'
[46] 字面量码 46 '.'
[47] 字面量码 102 'f'
[48] 长度码 261 ← 长度 7
[49] 距离码 10 + 偏移 0110 ← 距离 39
[50] 字面量码 61 '='
[51] 字面量码 33 '!'
[52] 长度码 271 + 偏移 10 ← 长度 29,注意长度也有偏移
[53] 距离码 9 + 偏移 110 ← 距离 31
[54] 字面量码 125 '}'
[55] 结束码 256 ← 最后会加上一个结束码
这里你可以将 长度码 271 + 偏移 10理解为一个整体,后续哈夫曼统计频率的时候只看长度码 271
这样是为了减少哈夫曼树的节点数量。 不替换的话,距离有 1~ 32768 共 32768 种取值,每种都要一个独立符号,哈夫曼树就得有 32768 个叶子;长度也有 3~258 共 256 种取值,同样要 256 个符号。替换之后,距离只剩 30 个「距离码」,长度只剩 29 个「长度码」。
拆完的符号分成两组,各建一棵树:
- 字面量 + 长度码 + 结束码 → 树 1(0~285,共 256 + 1 + 29 = 286 个);
- 距离码 → 树 2(0~29,共 30 个)。
两棵树合计 286 + 30 = 316 个叶子。
为什么不合成一棵? 因为解码端读完长度码(和偏移),就知道下一个必是距离码,可以直接切换。分成两棵树后,两棵树的码字可以重复——树 1 高频的字面量和树 2 高频的距离码都可以用 1–2 bit,互不冲突。合成一棵的话,所有码字必须在同一棵前缀树里互不冲突,常用的距离码就分不到和字面量一样短的码,反而更费 bits。
下面分别看树 1 和树 2 是怎么建的。
哈夫曼
哈夫曼的原理可以查看 B站视频 文件压缩原理——霍夫曼编码
因为值分成两类,所以要建两棵树,符号构成如下(顺序由 RFC 1951 规定):
| 树 | 符号 | 含义 |
|---|---|---|
| 树 1 | 0–255 | 字面量(256 个,符号值 = 字节值) |
| 树 1 | 256 | 块结束 EOB(1 个) |
| 树 1 | 257–285 | 长度码(29 个) |
| 树 2 | 0–29 | 距离码(30 个) |
树 1 共 286 个符号,树 2 共 30 个。距离码不参与树 1;解码时读到长度码、读完偏移,才切到树 2 读距离码。
码长表就是按这个顺序,给每个符号填一个 0–15 的码长:第 0 行是符号 0 的码长,第 1 行是符号 1 的码长……一直到符号 285。行号就是符号,符号名不用存。比如(只截取几行):
| 符号 | 码长 |
|---|---|
| 0 | 0 |
| 1 | 0 |
| ⋮ | ⋮ |
| 97 | 8 |
| 98 | 9 |
| ⋮ | ⋮ |
| 256 | 7 |
| 257 | 5 |
| ⋮ | ⋮ |
| 285 | 0 |
码长为 0 表示这个符号在本块没用到。解码端按同样的顺序把码长对回符号,重建 canonical Huffman 码。
码长表的传输
码长表通过 RLE + 第三棵哈夫曼树来传输
树 1 有 286 个码长,树 2 有 30 个,一共 316 个,每个 0–15。如果每个直接用 4 bit 传,就是 316 × 4 ≈ 1264 bit ≈ 158 字节/块。对 16K 符号的块来说,这个固定开销不小,所以 DEFLATE 把码长表本身也压了一遍。
注意:这里按完整表算(286 + 30 = 316),是最坏情况。实际块头的
HLIT/HDIST会截掉尾部没用到的 0,RLE 的输入是HLIT+257 + HDIST+1 = HLIT+HDIST+258个(258~316);下文说“316 个”时都按完整表理解。
第一步:RLE(游程编码)
码长序列里大量是 0(该块没用的符号),还有连续的相同码长。DEFLATE 为此定义了三个重复符号:
| 符号 | 含义 | 额外位 |
|---|---|---|
| 16 | 重复上一个码长 3–6 次 | 2 bit |
| 17 | 重复码长 0 共 3–10 次 | 3 bit |
| 18 | 重复码长 0 共 11–138 次 | 7 bit |
额外位存的是“相对区间起点的偏移”:16、17 的次数 = 3 + 额外位,18 的次数 = 11 + 额外位。
举个例子,假设某段码长是:
0 0 0 0 0 0 0 0 0 0 0 0 8 8 8 8 8 8 8 9 7
RLE 之后变成:
18(+1), 8, 16(+6), 9, 7
18(+1):12 个 0(11 + 1)8, 16(+6):7 个 8(1 + 6)9、7:原样
第二步:用第三棵树做 Huffman
经过 RLE,原来的 316 个码长变成了一串由 19 种符号组成的序列:0–15(码长值)+ 16/17/18(重复标记)。这时再照常统计这 19 种符号的频率,建一棵 Huffman 树——就是第三棵树,用它把 RLE 后的序列编码成 01 比特流。
还是上面的例子,RLE 后是 18, 8, 16, 9, 7。假设这 5 个符号各出现 1 次,第三棵树会给它们分配 2–3 bit 的码字,比如:
18 → 00
8 → 01
16 → 10
9 → 110
7 → 111
那 18, 8, 16, 9, 7 就编码成 00 01 10 110 111,再加上 18 和 16 的额外位,就是最终写进比特流的内容。
第三棵树自己的码长怎么传?
第三棵树有 19 个符号,每个也有一个 0–7 的码长。这 19 个码长不再压缩,而是每个用 3 bit 原样写进块头,按固定顺序(16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15)排列。实际只发到最后一个非零值,发送个数由 HCLEN 记录(HCLEN + 4 个),后面的解码端补 0。
为什么不再套第四棵树?因为最多 19 × 3 = 57 bit,再为第四棵树写描述,成本比省下来的还多,不划算。所以递归到这里就停了。
最后传出去的东西长这样
一个 dynamic block 的布局:
[3 bit] BFINAL + BTYPE
[5 bit] HLIT (树1 的符号数 - 257)
[5 bit] HDIST (树2 的符号数 - 1)
[4 bit] HCLEN (第三棵树的码长个数 - 4)
[HCLEN+4] × 3 bit 第三棵树的码长(原样)
[?] 树1 的码长序列(RLE + 第三棵树编码)
[?] 树2 的码长序列(RLE + 第三棵树编码)
[?] 实际数据(树1/树2 编码)
EOB
树 1 和树 2 的码长序列在格式上是一条连续序列,重复码允许跨过两表分界;不过常见实现通常两张表分开 RLE、不跨边界,解码端则必须支持跨边界。
上面说的「常见实现」主要指 zlib:一个 C 库,实现了 DEFLATE 的压缩和解压。nginx、Apache、Java 的 Deflater、curl、Node.js 的 gzip 压缩通常都由它完成。
解码时反过来
- 读 HCLEN+4 个 3-bit 码长 → 建第三棵树;
- 用第三棵树解出 RLE 序列,展开重复码 → 得到 316 个码长;
- 用这 316 个码长建树 1、树 2;
- 用树 1/树 2 解实际数据。
一句话总结:最后传的是「第三棵树的码长(原样)+ 用第三棵树编码的两张码长表(RLE 后)+ 用树 1/2 编码的数据」。
注意:dynamic 块要额外写码长表——第三棵树的描述本身就要 16–61 bit,再加上两棵树的码长序列。块太小时,这笔固定开销可能超过自定义树省下的,所以 dynamic 不一定划算。这也是 ### 分块 里“码长表本身也要写进块头,块够大才划算”的意思。上面的例子只演示机制;真实块的码长表最多 316 项,RLE + 第三棵树的收益才明显。
分块
块:LZ77 输出的 token 数组不是一次性全部编码,而是攒到一定数量(zlib 默认约 16384 个 token)就切一块, 每块单独建表、单独输出。块的目的是让码表贴合局部数据的分布。
三种编码方式:每块的数据收集完后,按这个顺序处理:
- 统计频率 → 建哈夫曼树 → 算出
dynamic的字节数 - 用 RFC 内置表 → 算出
fixed的字节数 - 原始长度 + 5 → 算出
stored的字节数 - 三者取最小,按选中的方式写这一块
块的类型
dynamic现建码长表 —— 码长表本身也要写进块头,块够大才划算fixed用 RFC 内置的码长表 —— 不用额外写表,适合小块stored直接存原文 —— 数据压不动时
交替执行:LZ77 攒满一块交给哈夫曼,再回来继续。 压缩时间通常由 LZ77 匹配搜索占大头。
最后一块处理完后,gzip 封装会把比特流补 0 到字节边界,再写 8 字节尾。
封装
DEFLATE 只产出压缩后的比特流;gzip 在它外面再套一层:
[10 字节 gzip 头] + [DEFLATE 流] + [8 字节 gzip 尾]
- 头(最少 10 字节):魔数、压缩方法、标志位、时间戳等。它在最开头就写好,不是最后才加。
- 尾(8 字节):CRC32(4 字节)+ 原始长度(4 字节),用来校验数据、还原原始大小。
所以一个 .gz 文件 = 10 字节头 + DEFLATE 流 + 8 字节尾。
解码的原理
字面量码直接按 树1 进行解码。
MATCH码 有些不同,
MATCH [len=5 dist=14] 这种经过哈夫曼输出后得到的比特流101101011101,
先查树1得到101101是 长度码259,然后查规范表得出长度码259对应的区间起点和偏移位数。偏移位数是0,所以长度码就到这里结束。然后会去树2查询距离码,距离码7的偏移位数是2,所以偏移要再往后读两位。
使用方式
nginx
在nginx.conf的http {}里面添加
gzip on;
gzip_comp_level 6;
gzip_min_length 1024;
gzip_vary on;
gzip_proxied any;
gzip_types
text/plain
text/css
text/markdown
application/javascript
application/json
application/manifest+json
application/xml
application/rss+xml
application/atom+xml
application/wasm
image/svg+xml;
Spring Boot
application.yml中配置:
server:
compression:
enabled: true
# 只压缩 JSON;这行会覆盖 Spring Boot 的默认类型列表
mime-types: application/json
min-response-size: 1024
server.compression.mime-types是覆盖而不是追加。只写application/json时,Spring Boot 默认的text/html、text/css、application/javascript等类型都不会再被压缩;如果站点还要返回这些静态资源,删掉这行改用默认列表,或者把类型列全。
补充
为什么用 LZ77 而不是字典编码
压缩的另一种思路是字典编码(LZ78 / LZW):把出现过的字符串建成字典,用编号引用。
两者逻辑: LZ77:往回 31 字节,抄 29 个 ← 指向输出缓冲区里的位置 LZW:字典第 4271 号 ← 指向一份共同维护的字典
两者都能表达"这里重复了",DEFLATE 选了前者,原因有五条:
- 解码器状态小:LZ77 的解码器只需要一个固定大小的窗口,不用像 LZW 那样和编码端同步维护一张字典;实现更简单,也不存在字典失步后整段解码错位的问题。
- 没有死条目:LZW 遇到新串就建条目,不管以后用不用得上,于是大量只出现一次的串也占着编号;LZ77 每条指令都是当场判断“抄这 5 个字节划不划算”,不划算就发一个字面量。
- 能重叠:LZ77 允许
距离 < 长度。16 个A可以写成LIT 'A'+MATCH(dist=1, len=15),因为解码时可以边抄边读自己。LZW 做不到——字典条目必须是"已经出现过的完整串",只能靠A → AA → AAA → AAAA逐级建条目,每个都要单独一个码。 - 距离码的字母表更小、更有序:LZ77 的距离有天然顺序(1 最近、32768 最远),近的距离更常见;先按范围压成 30 个码,这 30 个符号仍保留「越近越常见」的分布,Huffman 只需覆盖 30 个符号,码长表很小,还能每块重建、贴合局部分布。 LZW 的编号只代表建表顺序,跟频率没有稳定的对应关系;即使也套一层 Huffman,字母表仍有几千到几万个符号,码长表会大很多,按块重建的代价也高很多。
- 历史原因:LZW 当年有专利(Unisys),RFC 1951 §1.1 把"无专利"列为设计目标之一。
不过字典编码没有消失。Brotli 的静态字典(预置上万个常用词)、Zstandard 的字典模式,都是把"固定的高频短语"交给字典,把"零散的重复"交给 LZ77。
关于Brotli
Brotli 通常比 gzip 再小 15%~20%(主要来自静态字典和更大的窗口)。
但多数站点默认还是 gzip,原因有五条:
-
服务端不一定装了 brotli 模块 nginx 官方包不包含
ngx_brotli,要额外编译或另外装包;gzip 是内置的。 -
主流浏览器只在 HTTPS 下才发
Accept-Encoding: br纯 HTTP 的站点根本收不到 br 请求。 -
动态压缩时优势缩水 brotli 质量 11 压缩率最好,但速度比 gzip -6 慢一到两个数量级; 要跟上 gzip 的吞吐只能用低质量档,此时只比 gzip 小 5% 左右。
-
边际收益递减 从"不压"到 gzip 是 3~7 倍,从 gzip 到 br 只有 15%。
-
工具链惯性 抓包、日志分析、中间件对 gzip 的支持是三十多年的积累,br 要晚得多。
实践里常见的做法是"br 优先,gzip 兜底":客户端支持 br 就发 br,否则回落 gzip。
如果你的站点是静态资源为主(Vue/React 打包产物),br 的收益最大——因为可以在构建时用 q11 预压,运行时零成本。这时候 br 基本总是优于 gzip。
动态 API 收益就有限,gzip 够用。