Go compress/flate 怎样读取原始 DEFLATE 数据

我第一次把一段压缩数据交给 compress/flate 时，问题不在读取循环，而在输入格式判断：flate 处理的是 RFC 1951 定义的原始 DEFLATE 数据，gzip 和 zlib 则是在它外面又加了自己的头部与尾部。如果输入其实是 gzip 文件，直接调用 flate.NewReader 往往只会得到损坏输入错误。

官方地址：https://pkg.go.dev/compress/flate

读取原始 DEFLATE 的最小方案是用 flate.NewReader 创建 io.ReadCloser，循环消费解压后的字节，并把 io.EOF 当作正常结束；如果压缩端使用了预置字典，就必须改用带同一字典的 NewReaderDict。

先把原始 DEFLATE 和 gzip、zlib 分开

compress/flate 是编码格式层，负责 DEFLATE 的压缩块、Huffman 编码和回溯引用；compress/gzip 与 compress/zlib 是基于 DEFLATE 的文件或数据流封装。这个区别决定了解码器的入口：只有已经剥掉外层头尾的数据，才适合直接交给 flate.NewReader。

如果数据来自文件名为 .gz 的归档、HTTP 的 gzip 响应或带 zlib 头的协议字段，应先使用相应的包解析外层格式。只有协议明确写着“payload 是 raw DEFLATE”时，才在 payload 层使用本篇的读取方式。不要用“能否读出几个字节”来猜格式，因为错误可能在读到后续压缩块时才暴露。

用 NewReader 流式读取

NewReader 返回一个 io.ReadCloser。它不会一次把全部明文放进内存，而是随着调用方的 Read 请求逐段解码。读到 DEFLATE 最终块后返回 io.EOF 是正常结束；其他错误则应保留并交给上层，不能把所有非 nil 错误都当作“还有数据”。

func readRawDeflate(src io.Reader) ([]byte, error) {
	// NewReader 只负责原始 DEFLATE，不负责解析 gzip 或 zlib 外层头尾。
	zr := flate.NewReader(src)
	defer zr.Close()

	var out bytes.Buffer
	if _, err := io.Copy(&out, zr); err != nil {
		// io.Copy 遇到 io.EOF 会正常结束；这里留下的错误通常是输入损坏或底层读取失败。
		return nil, fmt.Errorf("读取原始 DEFLATE 失败: %w", err)
	}
	return out.Bytes(), nil
}

这个函数适合明文规模可控的场景。bytes.Buffer 会持续增长，如果输入来自不可信来源或可能很大，应把目标换成文件、管道或带上限的写入器，而不是为了方便把全部结果留在内存里。

把读取循环里的 EOF 和损坏输入分开

需要统计字节数、把明文分块交给下游或记录错误类型时，可以直接写循环。io.EOF 表示最后一个 DEFLATE 块已经被消费；flate.CorruptInputError 表示压缩数据在某个偏移附近不符合格式。底层 io.Reader 返回的网络或文件错误，也不应该被改写成压缩格式错误。

func copyRawDeflate(dst io.Writer, src io.Reader) (int64, error) {
	// 使用固定缓冲区，让下游逐块消费明文，不构造完整结果副本。
	zr := flate.NewReader(src)
	defer zr.Close()

	buf := make([]byte, 32*1024)
	var total int64
	for {
		n, err := zr.Read(buf)
		if n > 0 {
			written, writeErr := dst.Write(buf[:n])
			if writeErr != nil {
				return total, fmt.Errorf("写入解压结果失败: %w", writeErr)
			}
			total += int64(written)
			if written != n {
				return total, io.ErrShortWrite
			}
		}
		if err == io.EOF {
			// 最终块已读完，这是成功结束，不是异常。
			return total, nil
		}
		if err != nil {
			// 保留 flate 的具体错误，便于区分损坏输入和底层 I/O 失败。
			return total, fmt.Errorf("解压读取失败: %w", err)
		}
	}
}

循环里先处理 n > 0 再处理 err，是因为一个 Read 可以同时返回有效字节和错误。这样不会丢掉最后一小段明文，也不会把写入端的短写误报成压缩端问题。

判断底层 Reader 与尾部数据边界

flate.NewReader 接受 io.Reader，但它实际需要的更细接口是 flate.Reader，也就是同时具备 Read 和 ReadByte。如果传入对象没有 ReadByte，解码器会自己加缓冲，因此可能从底层多读一些数据。

官方语义还规定：读到最终 DEFLATE 块后返回 io.EOF，最终块之后的尾部数据会被忽略。这个边界很重要：

• 如果 raw DEFLATE 后面紧接着还有协议字段，不要假设 NewReader 会把底层位置精确停在字段起点。
• 如果协议要求严格校验“压缩流后不能有任何字节”，应在更外层设计明确的长度或帧边界，不要把 flate 的 EOF 当作整个消息的 EOF。
• 如果底层是 bufio.Reader 或实现了 ReadByte 的对象，缓冲边界更容易由调用方掌握，但仍应以协议 framing 为准。

需要预置字典时改用 NewReaderDict

某些压缩协议会把高频前缀放进预置字典，压缩端使用 flate.NewWriterDict，解压端就必须使用包含同一字节内容的 flate.NewReaderDict。字典不是“可选优化参数”，它参与了解码上下文；缺失、内容不同或版本不一致，都可能让后续数据无法恢复。

func readWithPresetDictionary(src io.Reader, dict []byte) ([]byte, error) {
	// 解压端必须使用与压缩端约定一致的字典内容。
	zr := flate.NewReaderDict(src, dict)
	defer zr.Close()

	data, err := io.ReadAll(zr)
	if err != nil {
		// 字典不匹配时保留原始错误，调用方可把它归入协议协商失败。
		return nil, fmt.Errorf("带字典读取失败: %w", err)
	}
	return data, nil
}

只有在协议明确规定字典来源时才使用这个入口。把一段普通 raw DEFLATE 数据“试着”用字典读取，会把输入边界问题和字典协商问题混在一起；更好的做法是让消息头、版本配置或会话协商先确定字典，再创建 reader。

批量输入用 Resetter 复用解码器

NewReader 和 NewReaderDict 返回的 reader 还实现了 flate.Resetter。批量处理许多短的 raw DEFLATE payload 时，可以让同一个解码器切换到新的底层 reader，减少反复创建解码器的开销。Reset 会丢弃已有缓冲并恢复到新 reader 的初始状态，字典参数也要随每段输入明确传入。

func decodeMany(inputs [][]byte, dict []byte) ([][]byte, error) {
	// 先创建一个占位 reader，后续通过 Resetter 切换真正的输入。
	zr := flate.NewReader(bytes.NewReader(nil))
	defer zr.Close()
	resetter, ok := zr.(flate.Resetter)
	if !ok {
		return nil, errors.New("flate reader 不支持 Resetter")
	}

	results := make([][]byte, 0, len(inputs))
	for _, input := range inputs {
		// Reset 会清掉上一段输入的缓冲；字典为空表示普通 raw DEFLATE。
		if err := resetter.Reset(bytes.NewReader(input), dict); err != nil {
			return nil, fmt.Errorf("重置解码器失败: %w", err)
		}
		plain, err := io.ReadAll(zr)
		if err != nil {
			return nil, fmt.Errorf("读取第 %d 段失败: %w", len(results)+1, err)
		}
		results = append(results, plain)
	}
	return results, nil
}

复用不是无条件更快：如果每段数据很大、并发度高，独立 reader 更容易隔离生命周期；如果每段都很短且处理是串行的，Reset 才更有意义。无论选哪种方式，都要保证上一段已经读完或被明确关闭，再把 reader 交给下一段。

把原始 DEFLATE 读取规则固定下来

常见问题

为什么 gzip 文件不能直接交给 flate.NewReader？

因为 gzip 是带头部、尾部校验和等信息的外层格式，flate 只期待 RFC 1951 的 DEFLATE 数据。应使用 compress/gzip 先处理 gzip 封装。

读到 io.EOF 还需要检查错误吗？

需要区分。io.EOF 是最终块后的正常结束，flate.CorruptInputError、底层文件错误或网络错误都应继续向上返回。

NewReader 会严格停在压缩流末尾吗？

它在最终 DEFLATE 块后返回 EOF，并忽略最终块之后的尾部数据。若协议还包含后续字段，要靠外层长度或帧协议管理边界。

什么时候必须使用 NewReaderDict？

只有压缩端明确使用了预置字典时。解压端必须拿到同一字典，否则不能把结果当作普通 raw DEFLATE 来处理。