Golang实现数据存储到归档文件的最佳实践

对于你的需求，直接使用标准库的archive/zip确实无法实现向现有zip文件追加内容，因为zip格式的中央目录结构在文件末尾，修改时需要重写整个文件。不过，可以通过以下两种方式实现你的需求：

方案一：使用临时文件进行重建（推荐）

每次运行时读取现有归档，添加新文件/数据后写入新归档文件，最后替换原文件。这种方式兼容标准zip格式：

package main

import (
    "archive/zip"
    "bytes"
    "io"
    "os"
    "path/filepath"
)

func appendToZip(zipPath string, newFiles map[string][]byte) error {
    // 创建临时文件
    tmpFile, err := os.CreateTemp(filepath.Dir(zipPath), "temp-*.zip")
    if err != nil {
        return err
    }
    defer os.Remove(tmpFile.Name())
    defer tmpFile.Close()

    // 创建zip写入器
    zipWriter := zip.NewWriter(tmpFile)
    defer zipWriter.Close()

    // 1. 复制现有zip中的文件（如果存在）
    if _, err := os.Stat(zipPath); err == nil {
        existingZip, err := zip.OpenReader(zipPath)
        if err == nil {
            defer existingZip.Close()
            
            for _, file := range existingZip.File {
                rc, err := file.Open()
                if err != nil {
                    return err
                }
                
                // 创建zip文件头
                header := &zip.FileHeader{
                    Name:   file.Name,
                    Method: file.Method,
                }
                header.SetModTime(file.ModTime())
                
                writer, err := zipWriter.CreateHeader(header)
                if err != nil {
                    rc.Close()
                    return err
                }
                
                _, err = io.Copy(writer, rc)
                rc.Close()
                if err != nil {
                    return err
                }
            }
        }
    }

    // 2. 添加新文件或追加数据到现有文件
    for filename, content := range newFiles {
        // 检查是否已存在同名文件
        var existingContent []byte
        if _, err := os.Stat(zipPath); err == nil {
            existingZip, err := zip.OpenReader(zipPath)
            if err == nil {
                for _, file := range existingZip.File {
                    if file.Name == filename {
                        rc, err := file.Open()
                        if err == nil {
                            existingContent, _ = io.ReadAll(rc)
                            rc.Close()
                        }
                        break
                    }
                }
                existingZip.Close()
            }
        }

        // 合并旧数据和新数据
        combinedContent := append(existingContent, content...)
        
        // 创建新文件条目
        writer, err := zipWriter.Create(filename)
        if err != nil {
            return err
        }
        
        _, err = writer.Write(combinedContent)
        if err != nil {
            return err
        }
    }

    // 关闭zip写入器以确保数据写入
    if err := zipWriter.Close(); err != nil {
        return err
    }
    
    // 关闭临时文件
    if err := tmpFile.Close(); err != nil {
        return err
    }

    // 替换原文件
    return os.Rename(tmpFile.Name(), zipPath)
}

// 使用示例
func main() {
    newFiles := map[string][]byte{
        "log1.txt": []byte("New log entry\n"),
        "data.csv": []byte("2024-01-01,value1\n"),
    }
    
    err := appendToZip("archive.zip", newFiles)
    if err != nil {
        panic(err)
    }
}

方案二：使用支持追加的归档格式

考虑使用支持追加的文件格式，如tar配合gzip压缩。虽然标准库的archive/tar也不直接支持修改，但可以通过类似的重建方式实现：

package main

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

func appendToTarGz(tarPath string, newFiles map[string][]byte) error {
    tmpFile, err := os.CreateTemp(filepath.Dir(tarPath), "temp-*.tar.gz")
    if err != nil {
        return err
    }
    defer os.Remove(tmpFile.Name())
    defer tmpFile.Close()

    gzWriter := gzip.NewWriter(tmpFile)
    tarWriter := tar.NewWriter(gzWriter)

    // 读取现有tar文件
    if _, err := os.Stat(tarPath); err == nil {
        file, err := os.Open(tarPath)
        if err == nil {
            defer file.Close()
            
            gzReader, err := gzip.NewReader(file)
            if err == nil {
                defer gzReader.Close()
                
                tarReader := tar.NewReader(gzReader)
                for {
                    header, err := tarReader.Next()
                    if err == io.EOF {
                        break
                    }
                    if err != nil {
                        return err
                    }
                    
                    // 跳过要更新的文件（后面会重新添加）
                    if _, exists := newFiles[header.Name]; exists {
                        continue
                    }
                    
                    // 复制其他文件
                    if err := tarWriter.WriteHeader(header); err != nil {
                        return err
                    }
                    if _, err := io.Copy(tarWriter, tarReader); err != nil {
                        return err
                    }
                }
            }
        }
    }

    // 添加/更新文件
    for filename, content := range newFiles {
        header := &tar.Header{
            Name: filename,
            Mode: 0644,
            Size: int64(len(content)),
        }
        
        if err := tarWriter.WriteHeader(header); err != nil {
            return err
        }
        if _, err := tarWriter.Write(content); err != nil {
            return err
        }
    }

    tarWriter.Close()
    gzWriter.Close()
    tmpFile.Close()
    
    return os.Rename(tmpFile.Name(), tarPath)
}

方案三：使用第三方库

如果需要更高效的解决方案，可以考虑以下第三方库：

1. github.com/yeka/zip - 支持向现有zip文件添加文件
2. github.com/klauspost/compress/zip - 性能优化的zip库，支持流式处理

示例使用github.com/yeka/zip：

import "github.com/yeka/zip"

func appendWithYekaZip(zipPath string, filename string, content []byte) error {
    // 打开现有zip文件（如果存在）
    var zipFile *zip.ReadCloser
    if _, err := os.Stat(zipPath); err == nil {
        zipFile, err = zip.OpenReader(zipPath)
        if err != nil {
            return err
        }
        defer zipFile.Close()
    }

    // 创建新zip文件
    newZip, err := os.Create(zipPath + ".new")
    if err != nil {
        return err
    }
    defer os.Remove(newZip.Name())
    defer newZip.Close()

    zipWriter := zip.NewWriter(newZip)
    
    // 复制现有文件
    if zipFile != nil {
        for _, file := range zipFile.File {
            writer, err := zipWriter.Create(file.Name)
            if err != nil {
                return err
            }
            
            rc, err := file.Open()
            if err != nil {
                return err
            }
            
            io.Copy(writer, rc)
            rc.Close()
        }
    }
    
    // 添加新文件
    writer, err := zipWriter.Create(filename)
    if err != nil {
        return err
    }
    
    writer.Write(content)
    zipWriter.Close()
    
    // 替换原文件
    return os.Rename(newZip.Name(), zipPath)
}

选择哪种方案取决于你的具体需求：

• 如果数据量不大，方案一的临时文件方法最可靠
• 如果需要更好的压缩性能，方案二的tar+gzip可能更合适
• 如果频繁追加且性能要求高，方案三的第三方库值得考虑