Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Go 语言标准库 —— compress/bzip2 包（Bzip2 解压缩）

🔹 概述

compress/bzip2 包实现了 Bzip2 压缩格式的解压缩功能。

主要功能：

  • Bzip2 格式解压缩
  • 读取 .bz2 文件
  • 流式解压缩
  • 高效内存使用

重要说明：

  • ⚠️ 仅支持解压缩，不支持压缩
  • ⚠️ 需要压缩功能可使用第三方库（如 github.com/dsnet/compress/bzip2）
  • Bzip2 压缩率高于 gzip，但速度较慢
  • 适用于需要高压缩率的场景

🔹 核心类型

Bzip2 读取器

bzip2.Reader struct

  • 说明：

    • 实现了 io.Reader 接口
    • 从底层读取器读取压缩数据并解压缩
    • 流式处理，不需要一次性加载全部数据

  • 字段：

    • 内部自动管理，无需手动操作

  • 创建方式：

    // 从 io.Reader 创建
func NewReader(r io.Reader) io.Reader

  • 常用方法详解

    • Read 方法
      • 说明：读取并解压缩数据
      • 方法：Read(p []byte) (n int, err error)
      • 注意：
        • 实现了 io.Reader 接口
        • 自动处理解压缩
        • 读到末尾返回 io.EOF
      • 示例： 
        // 从文件读取
file, _ := os.Open("data.bz2")
defer file.Close()

reader := bzip2.NewReader(file)
buf := make([]byte, 1024)
n, err := reader.Read(buf)

  • 示例（完整）

    package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func main() {
	// 打开 .bz2 文件
	file, err := os.Open("data.txt.bz2")
	if err != nil {
		fmt.Println("打开文件失败:", err)
		return
	}
	defer file.Close()

	// 创建 bzip2 读取器
	reader := bzip2.NewReader(file)

	// 读取并解压缩
	data, err := io.ReadAll(reader)
	if err != nil {
		fmt.Println("读取失败:", err)
		return
	}

	fmt.Printf("解压后大小：%d 字节\n", len(data))
	fmt.Printf("内容：%s\n", string(data[:100])) // 显示前 100 字节
}

🔹 使用场景

1. 读取 .bz2 文件

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func main() {
	// 打开压缩文件
	file, err := os.Open("archive.bz2")
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
	defer file.Close()

	// 创建解压缩读取器
	reader := bzip2.NewReader(file)

	// 读取所有内容
	content, err := io.ReadAll(reader)
	if err != nil {
		fmt.Println("解压失败:", err)
		return
	}

	fmt.Printf("解压成功，大小：%d 字节\n", len(content))
}

2. 逐行读取大文件

package main

import (
	"bufio"
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func main() {
	file, err := os.Open("large.log.bz2")
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
	defer file.Close()

	// 创建 bzip2 读取器
	reader := bzip2.NewReader(file)

	// 使用 bufio.Scanner 逐行读取
	scanner := bufio.NewScanner(reader)
	lineCount := 0

	for scanner.Scan() {
		line := scanner.Text()
		lineCount++
		
		// 处理每一行
		if lineCount <= 5 {
			fmt.Printf("第 %d 行：%s\n", lineCount, line)
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("读取错误:", err)
		return
	}

	fmt.Printf("总共 %d 行\n", lineCount)
}

3. 复制到文件

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func main() {
	// 打开压缩文件
	srcFile, err := os.Open("data.txt.bz2")
	if err != nil {
		fmt.Println("打开源文件失败:", err)
		return
	}
	defer srcFile.Close()

	// 创建目标文件
	dstFile, err := os.Create("data.txt")
	if err != nil {
		fmt.Println("创建目标文件失败:", err)
		return
	}
	defer dstFile.Close()

	// 创建解压缩读取器
	reader := bzip2.NewReader(srcFile)

	// 复制解压后的数据到目标文件
	n, err := io.Copy(dstFile, reader)
	if err != nil {
		fmt.Println("复制失败:", err)
		return
	}

	fmt.Printf("解压完成，写入 %d 字节\n", n)
}

4. 从 HTTP 响应读取

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	// 下载并解压 .bz2 文件
	resp, err := http.Get("https://example.com/data.bz2")
	if err != nil {
		fmt.Println("下载失败:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Println("HTTP 错误:", resp.Status)
		return
	}

	// 创建解压缩读取器
	reader := bzip2.NewReader(resp.Body)

	// 保存到本地
	file, err := os.Create("downloaded.txt")
	if err != nil {
		fmt.Println("创建文件失败:", err)
		return
	}
	defer file.Close()

	n, err := io.Copy(file, reader)
	if err != nil {
		fmt.Println("保存失败:", err)
		return
	}

	fmt.Printf("下载并解压完成，大小：%d 字节\n", n)
}

5. 与 tar 包配合使用（解压 .tar.bz2）

package main

import (
	"archive/tar"
	"compress/bzip2"
	"fmt"
	"io"
	"os"
	"path/filepath"
)

func extractTarBz2(filename, dest string) error {
	// 打开 .tar.bz2 文件
	file, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer file.Close()

	// 创建 bzip2 读取器
	bz2Reader := bzip2.NewReader(file)

	// 创建 tar 读取器
	tarReader := tar.NewReader(bz2Reader)

	// 遍历 tar 归档
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		// 构建目标路径
		targetPath := filepath.Join(dest, header.Name)

		// 根据文件类型处理
		switch header.Typeflag {
		case tar.TypeDir:
			// 创建目录
			if err := os.MkdirAll(targetPath, os.FileMode(header.Mode)); err != nil {
				return err
			}

		case tar.TypeReg:
			// 创建父目录
			if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
				return err
			}

			// 创建文件
			outFile, err := os.Create(targetPath)
			if err != nil {
				return err
			}

			// 复制文件内容
			if _, err := io.Copy(outFile, tarReader); err != nil {
				outFile.Close()
				return err
			}
			outFile.Close()

		default:
			fmt.Printf("跳过未知类型：%s\n", header.Name)
		}
	}

	return nil
}

func main() {
	err := extractTarBz2("archive.tar.bz2", "./output")
	if err != nil {
		fmt.Println("解压失败:", err)
		return
	}
	fmt.Println("解压成功")
}

6. 管道处理

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
	"strings"
)

func main() {
	// 模拟压缩数据（实际应从文件读取）
	compressedData := "..." // 实际的 bzip2 压缩数据

	// 创建读取器
	reader := bzip2.NewReader(strings.NewReader(compressedData))

	// 使用 io.Pipe 进行管道处理
	pr, pw := io.Pipe()

	go func() {
		defer pw.Close()
		_, err := io.Copy(pw, reader)
		if err != nil {
			pw.CloseWithError(err)
		}
	}()

	// 从管道读取
	data, err := io.ReadAll(pr)
	if err != nil {
		fmt.Println("读取失败:", err)
		return
	}

	fmt.Printf("处理完成：%d 字节\n", len(data))
}

7. 批量处理多个文件

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

func decompressAllBz2(dir string) error {
	// 查找所有 .bz2 文件
	files, err := filepath.Glob(filepath.Join(dir, "*.bz2"))
	if err != nil {
		return err
	}

	for _, file := range files {
		fmt.Printf("处理：%s\n", file)

		// 打开压缩文件
		srcFile, err := os.Open(file)
		if err != nil {
			fmt.Printf("  打开失败：%v\n", err)
			continue
		}

		// 创建目标文件（移除 .bz2 后缀）
		targetPath := strings.TrimSuffix(file, ".bz2")
		dstFile, err := os.Create(targetPath)
		if err != nil {
			srcFile.Close()
			fmt.Printf("  创建目标文件失败：%v\n", err)
			continue
		}

		// 解压
		reader := bzip2.NewReader(srcFile)
		_, err = io.Copy(dstFile, reader)

		srcFile.Close()
		dstFile.Close()

		if err != nil {
			fmt.Printf("  解压失败：%v\n", err)
			// 删除不完整的目标文件
			os.Remove(targetPath)
			continue
		}

		fmt.Printf("  解压成功：%s\n", targetPath)
	}

	return nil
}

func main() {
	err := decompressAllBz2("./downloads")
	if err != nil {
		fmt.Println("批量处理失败:", err)
		return
	}
	fmt.Println("批量处理完成")
}

🔹 错误处理

常见错误

  • 文件不存在

    • 说明：尝试打开不存在的 .bz2 文件
    • 处理方式：检查文件是否存在
    • 示例： 
      file, err := os.Open("data.bz2")
if os.IsNotExist(err) {
	fmt.Println("文件不存在")
	return
}

  • 无效的 bzip2 格式

    • 说明：文件不是有效的 bzip2 格式
    • 处理方式：读取时捕获错误
    • 示例： 
      reader := bzip2.NewReader(file)
_, err := io.ReadAll(reader)
if err != nil {
	fmt.Println("无效的 bzip2 格式:", err)
}

  • 数据损坏

    • 说明：压缩数据损坏或不完整
    • 处理方式：检查错误并重新下载/获取数据
    • 示例： 
      n, err := io.Copy(dst, reader)
if err != nil {
	fmt.Printf("解压到 %d 字节时出错：%v\n", n, err)
}

  • 权限错误

    • 说明：没有文件读取或写入权限
    • 处理方式：检查文件权限
    • 示例： 
      file, err := os.Open("data.bz2")
if os.IsPermission(err) {
	fmt.Println("没有读取权限")
	return
}

错误处理最佳实践

package main

import (
	"compress/bzip2"
	"errors"
	"fmt"
	"io"
	"os"
)

func decompressFile(src, dst string) error {
	// 检查源文件
	info, err := os.Stat(src)
	if os.IsNotExist(err) {
		return fmt.Errorf("源文件不存在：%s", src)
	}
	if err != nil {
		return fmt.Errorf("检查文件失败：%w", err)
	}

	// 检查文件大小
	if info.Size() == 0 {
		return errors.New("源文件为空")
	}

	// 打开源文件
	srcFile, err := os.Open(src)
	if err != nil {
		return fmt.Errorf("打开源文件失败：%w", err)
	}
	defer srcFile.Close()

	// 创建目标文件
	dstFile, err := os.Create(dst)
	if err != nil {
		return fmt.Errorf("创建目标文件失败：%w", err)
	}
	defer func() {
		dstFile.Close()
		if err != nil {
			// 出错时删除不完整的文件
			os.Remove(dst)
		}
	}()

	// 创建解压缩读取器
	reader := bzip2.NewReader(srcFile)

	// 解压
	written, err := io.Copy(dstFile, reader)
	if err != nil {
		return fmt.Errorf("解压失败（已写入 %d 字节）: %w", written, err)
	}

	fmt.Printf("解压成功：%s -> %s (%d 字节)\n", src, dst, written)
	return nil
}

func main() {
	err := decompressFile("data.txt.bz2", "data.txt")
	if err != nil {
		fmt.Println("错误:", err)
		os.Exit(1)
	}
}

🔹 性能优化

1. 使用缓冲读取

package main

import (
	"bufio"
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func main() {
	file, err := os.Open("large.bz2")
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
	defer file.Close()

	// 使用 bufio 缓冲读取，提高性能
	reader := bzip2.NewReader(file)
	bufReader := bufio.NewReaderSize(reader, 32*1024) // 32KB 缓冲

	// 处理数据
	buffer := make([]byte, 8192)
	total := 0

	for {
		n, err := bufReader.Read(buffer)
		total += n

		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("读取错误:", err)
			return
		}

		// 处理 buffer[:n]
	}

	fmt.Printf("处理完成：%d 字节\n", total)
}

2. 并发处理

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
	"sync"
)

func decompressConcurrent(files []string) {
	var wg sync.WaitGroup
	errors := make(chan error, len(files))

	for _, file := range files {
		wg.Add(1)
		go func(src string) {
			defer wg.Done()

			// 打开文件
			srcFile, err := os.Open(src)
			if err != nil {
				errors <- fmt.Errorf("打开 %s 失败：%w", src, err)
				return
			}
			defer srcFile.Close()

			// 创建目标文件
			dst := src[:len(src)-4] // 移除 .bz2
			dstFile, err := os.Create(dst)
			if err != nil {
				errors <- fmt.Errorf("创建 %s 失败：%w", dst, err)
				return
			}
			defer dstFile.Close()

			// 解压
			reader := bzip2.NewReader(srcFile)
			_, err = io.Copy(dstFile, reader)
			if err != nil {
				errors <- fmt.Errorf("解压 %s 失败：%w", src, err)
				return
			}

			fmt.Printf("解压成功：%s\n", dst)
		}(file)
	}

	// 等待所有 goroutine 完成
	go func() {
		wg.Wait()
		close(errors)
	}()

	// 收集错误
	for err := range errors {
		fmt.Println("错误:", err)
	}
}

func main() {
	files := []string{"file1.bz2", "file2.bz2", "file3.bz2"}
	decompressConcurrent(files)
}

3. 内存限制

package main

import (
	"compress/bzip2"
	"errors"
	"fmt"
	"io"
	"os"
)

// 限制最大读取大小
type limitedReader struct {
	r     io.Reader
	limit int64
	n     int64
}

func (lr *limitedReader) Read(p []byte) (int, error) {
	if lr.limit <= 0 {
		return 0, errors.New("超出大小限制")
	}
	if int64(len(p)) > lr.limit {
		p = p[:lr.limit]
	}

	n, err := lr.r.Read(p)
	lr.n += int64(n)
	lr.limit -= int64(n)

	return n, err
}

func main() {
	file, err := os.Open("data.bz2")
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
	defer file.Close()

	reader := bzip2.NewReader(file)

	// 限制最大解压为 100MB
	limited := &limitedReader{r: reader, limit: 100 * 1024 * 1024}

	data, err := io.ReadAll(limited)
	if err != nil {
		fmt.Println("读取失败:", err)
		return
	}

	fmt.Printf("解压成功：%d 字节\n", len(data))
}

🔹 与其他压缩格式对比

Bzip2 vs Gzip vs Zlib

特性Bzip2GzipZlib
压缩率高中中
压缩速度慢快快
解压速度中快快
内存使用高低低
Go 标准库支持仅解压压缩 + 解压压缩 + 解压
文件扩展名.bz2.gz.zlib
适用场景归档存储网络传输内存压缩

选择建议

  • Bzip2 👉 需要高压缩率的归档场景
  • Gzip 👉 网络传输、日志压缩
  • Zlib 👉 内存中的压缩操作

🔹 实际应用示例

1. 日志文件解压分析

package main

import (
	"bufio"
	"compress/bzip2"
	"fmt"
	"io"
	"os"
	"strings"
)

func analyzeLog(filename string) error {
	file, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer file.Close()

	reader := bzip2.NewReader(file)
	scanner := bufio.NewScanner(reader)

	errorCount := 0
	warnCount := 0
	infoCount := 0

	for scanner.Scan() {
		line := scanner.Text()
		
		if strings.Contains(line, "ERROR") {
			errorCount++
		} else if strings.Contains(line, "WARN") {
			warnCount++
		} else if strings.Contains(line, "INFO") {
			infoCount++
		}
	}

	if err := scanner.Err(); err != nil {
		return err
	}

	fmt.Printf("日志分析结果:\n")
	fmt.Printf("  ERROR: %d\n", errorCount)
	fmt.Printf("  WARN:  %d\n", warnCount)
	fmt.Printf("  INFO:  %d\n", infoCount)

	return nil
}

func main() {
	err := analyzeLog("application.log.bz2")
	if err != nil {
		fmt.Println("分析失败:", err)
		return
	}
}

2. 压缩文件比较

package main

import (
	"compress/bzip2"
	"crypto/md5"
	"fmt"
	"io"
	"os"
)

func compareBz2Files(file1, file2 string) (bool, error) {
	// 计算第一个文件的 MD5
	hash1, err := computeMD5(file1)
	if err != nil {
		return false, err
	}

	// 计算第二个文件的 MD5
	hash2, err := computeMD5(file2)
	if err != nil {
		return false, err
	}

	return hash1 == hash2, nil
}

func computeMD5(filename string) (string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return "", err
	}
	defer file.Close()

	reader := bzip2.NewReader(file)
	hash := md5.New()

	if _, err := io.Copy(hash, reader); err != nil {
		return "", err
	}

	return fmt.Sprintf("%x", hash.Sum(nil)), nil
}

func main() {
	same, err := compareBz2Files("file1.txt.bz2", "file2.txt.bz2")
	if err != nil {
		fmt.Println("比较失败:", err)
		return
	}

	if same {
		fmt.Println("两个文件内容相同")
	} else {
		fmt.Println("两个文件内容不同")
	}
}

3. 流式解压大文件

package main

import (
	"compress/bzip2"
	"fmt"
	"io"
	"os"
)

func streamDecompress(src, dst string, bufferSize int) error {
	// 打开源文件
	srcFile, err := os.Open(src)
	if err != nil {
		return fmt.Errorf("打开源文件：%w", err)
	}
	defer srcFile.Close()

	// 创建目标文件
	dstFile, err := os.Create(dst)
	if err != nil {
		return fmt.Errorf("创建目标文件：%w", err)
	}
	defer dstFile.Close()

	// 创建解压缩读取器
	reader := bzip2.NewReader(srcFile)

	// 使用缓冲区复制
	buf := make([]byte, bufferSize)
	total := int64(0)

	for {
		n, err := reader.Read(buf)
		if n > 0 {
			_, werr := dstFile.Write(buf[:n])
			if werr != nil {
				return fmt.Errorf("写入失败：%w", werr)
			}
			total += int64(n)
			
			// 显示进度
			if total%(1024*1024) == 0 {
				fmt.Printf("已解压：%d MB\n", total/(1024*1024))
			}
		}

		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("读取失败：%w", err)
		}
	}

	fmt.Printf("解压完成：%d 字节\n", total)
	return nil
}

func main() {
	err := streamDecompress("large.bz2", "large.txt", 64*1024)
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
}

🔹 注意事项和最佳实践

1. 仅支持解压

  • ⚠️ 重要：compress/bzip2 只支持解压缩，不支持压缩
  • 需要压缩功能时使用第三方库： 
    import "github.com/dsnet/compress/bzip2"

2. 错误处理

  • ✅ 始终检查 io.EOF
  • ✅ 使用 defer 关闭文件
  • ✅ 处理部分读取的错误情况

3. 性能优化

  • ✅ 使用 bufio 缓冲读取
  • ✅ 对于大文件使用流式处理
  • ✅ 批量处理时使用并发

4. 内存管理

  • ✅ 大文件使用 io.Copy 而不是 io.ReadAll
  • ✅ 设置合理的缓冲区大小
  • ✅ 注意内存限制

5. 文件扩展名约定

  • ✅ 使用 .bz2 扩展名
  • ✅ .tar.bz2 表示 tar 归档的 bzip2 压缩

🔥 总结

核心类型

  • bzip2.Reader 👉 Bzip2 解压缩读取器（实现了 io.Reader）

核心函数

  • bzip2.NewReader(r io.Reader) 👉 创建新的 Bzip2 读取器

主要特点

  • 仅解压 👉 标准库只提供解压功能
  • 流式处理 👉 不需要一次性加载全部数据
  • 高压缩率 👉 压缩率高于 gzip
  • io.Reader 接口 👉 与标准库完美集成

使用场景

  • 日志文件 👉 解压分析压缩的日志
  • 数据归档 👉 解压 .tar.bz2 归档
  • 网络传输 👉 接收压缩数据并解压
  • 批量处理 👉 批量解压多个 .bz2 文件

与其他包配合

  • archive/tar 👉 处理 .tar.bz2 文件
  • bufio 👉 提高读取性能
  • io 👉 Copy、ReadAll 等操作

最佳实践

  • ✅ 使用 defer 确保文件关闭
  • ✅ 大文件使用流式处理
  • ✅ 使用缓冲提高性能
  • ✅ 完善的错误处理
  • ✅ 并发处理多个文件
  • ⚠️ 注意：仅支持解压，不支持压缩

第三方压缩库

需要压缩功能时推荐：

  • github.com/dsnet/compress/bzip2 👉 完整的 bzip2 实现
  • github.com/ulikunitz/xz 👉 支持更多格式

compress/bzip2 包提供了高效的 Bzip2 解压缩功能，适合处理高压缩率的归档文件！