Go语言利用compress/gzip库实现高效压缩解决方案详解

func newGzipWriter(w io.Writer, level int) *gzip.Writer {
    writer := gzip.NewWriter(w)
    writer.SetLevel(level) // 设置压缩级别
    return writer
}

func decompressData(r io.Reader) ([]byte, error) {
    gzReader, err := gzip.NewReader(r)
    if err != nil {
        return nil, fmt.Errorf("invalid gzip stream: %v", err)
    }
    defer gzReader.Close()
    
    var buf bytes.Buffer
    _, err = buf.ReadFrom(gzReader)
    return buf.Bytes(), err
}

writer := gzip.NewWriter(file)
writer.Name = "data.txt"       // 设置原始文件名
writer.ModTime = time.Now()    // 设置修改时间
writer.Comment = "compressed data" // 添加注释

func compressFile(srcPath, dstPath string, level int) error {
    srcFile, err := os.Open(srcPath)
    if err != nil {
        return err
    }
    defer srcFile.Close()
    
    dstFile, err := os.Create(dstPath)
    if err != nil {
        return err
    }
    defer dstFile.Close()
    
    gzWriter := gzip.NewWriter(dstFile)
    gzWriter.SetLevel(level)
    defer gzWriter.Close() // 确保写入尾部校验信息
    
    _, err = io.Copy(gzWriter, srcFile) // 直接复制流数据进行压缩
    return err
}

func decompressFile(srcPath, dstPath string) error {
    srcFile, err := os.Open(srcPath)
    if err != nil {
        return err
    }
    defer srcFile.Close()
    
    gzReader, err := gzip.NewReader(srcFile)
    if err != nil {
        return fmt.Errorf("failed to create gzip reader: %v", err)
    }
    defer gzReader.Close()
    
    dstFile, err := os.Create(dstPath)
    if err != nil {
        return err
    }
    defer dstFile.Close()
    
    _, err = io.Copy(dstFile, gzReader) // 解压缩流数据到目标文件
    return err
}

func gzipMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 检查客户端是否支持gzip
        if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
            next.ServeHTTP(w, r)
            return
        }
        
        w.Header().Set("Content-Encoding", "gzip")
        gzWriter := gzip.NewWriter(w)
        defer gzWriter.Close()
        
        // 使用自定义ResponseWriter包装原始Writer
        gzResponse := &gzipResponseWriter{w, gzWriter}
        next.ServeHTTP(gzResponse, r)
    })
}

type gzipResponseWriter struct {
    http.ResponseWriter
    gzWriter *gzip.Writer
}

func (grw *gzipResponseWriter) Write(p []byte) (int, error) {
    return grw.gzWriter.Write(p)
}

func compressInMemory(data []byte, level int) ([]byte, error) {
    var buf bytes.Buffer
    gzWriter := gzip.NewWriter(&buf)
    gzWriter.SetLevel(level)
    defer gzWriter.Close()
    
    _, err := gzWriter.Write(data)
    return buf.Bytes(), err
}

func decompressInMemory(compressedData []byte) ([]byte, error) {
    reader := bytes.NewReader(compressedData)
    gzReader, err := gzip.NewReader(reader)
    if err != nil {
        return nil, err
    }
    defer gzReader.Close()
    
    var buf bytes.Buffer
    _, err = buf.ReadFrom(gzReader)
    return buf.Bytes(), err
}

gzWriter := gzip.NewWriter(w)
defer gzWriter.Close() // 必须执行，否则文件不完整

buffer := make([]byte, 4096)
for n := 0; n < len(data); n += 4096 {
    end := n + 4096
    if end > len(data) {
        end = len(data)
    }
    gzWriter.Write(data[n:end]) // 分块处理
}

gzReader, err := gzip.NewReader(r)
if err != nil {
    if err == gzip.ErrHeader {
        return nil, fmt.Errorf("invalid gzip header")
    }
    return nil, err
}

reader, writer := io.Pipe()
gzWriter := gzip.NewWriter(writer)
defer gzWriter.Close()

go func() {
    defer writer.Close()
    io.Copy(gzWriter, largeFile) // 流式压缩
}()

// 读取pipe中的压缩数据，避免内存峰值
io.Copy(dst, reader)

var buf bytes.Buffer
gzWriter := gzip.NewWriter(&buf)
for _, data := range dataChunks {
    buf.Reset()          // 重置缓冲区
    gzWriter.Reset(&buf) // 重置Writer到新目标
    gzWriter.Write(data) // 重复使用压缩实例
    processCompressed(buf.Bytes())
}

// 压缩时添加缓冲写入
writer := bufio.NewWriterSize(file, 1<<20) // 1MB缓冲
defer writer.Flush()
gzWriter := gzip.NewWriter(writer)

// 解压缩时添加缓冲读取
reader := bufio.NewReaderSize(file, 1<<20)
gzReader := gzip.NewReader(reader)