Go语言实现持久化与原子性文件存储的教程

if err := os.MkdirAll(document.FileDirectory(), 0600); err != nil {
    return "", err
}

file, err := os.Create(document.TmpFile()) // 创建临时文件
if err != nil {
    return "", err
}
defer file.Close() // 确保文件在函数退出时关闭

file.Write(document.Data) // 写入数据到临时文件
if err := file.Sync(); err != nil { // 强制将数据同步到物理存储
    return "", err
}

if err := os.Rename(document.TmpFile(), document.File()); err != nil {
    os.Remove(document.TmpFile()) // 重命名失败时清理临时文件
    return "", err
}

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "path/filepath"
    "crypto/sha256"
    "encoding/hex"
)

// Document 结构体，模拟文档数据和其存储路径逻辑
type Document struct {
    Data []byte
    Hash string // 存储数据的哈希值
}

// NewDocument 创建一个新文档实例
func NewDocument(data []byte) *Document {
    h := sha256.New()
    h.Write(data)
    hash := hex.EncodeToString(h.Sum(nil))
    return &Document{
        Data: data,
        Hash: hash,
    }
}

// FileDirectory 根据哈希值生成文件存储目录
// 示例：哈希前两字符作为一级目录，接下来的两字符作为二级目录
func (d Document) FileDirectory() string {
    if len(d.Hash) < 4 {
        return "data" // 默认目录，或处理错误
    }
    return filepath.Join("data", d.Hash[0:2], d.Hash[2:4])
}

// File 生成最终文件的完整路径
func (d Document) File() string {
    return filepath.Join(d.FileDirectory(), d.Hash[4:])
}

// TmpFile 生成临时文件的完整路径
func (d Document) TmpFile() string {
    return d.File() + ".tmp"
}

// Save 方法：实现持久化与原子性的数据存储
func (d Document) Save() (hash string, err error) {
    // 1. 确保目标目录存在
    if err := os.MkdirAll(d.FileDirectory(), 0700); err != nil { // 使用0700确保目录所有者有读写执行权限
        return "", fmt.Errorf("创建目录失败: %w", err)
    }

    // 2. 创建临时文件
    tmpFilePath := d.TmpFile()
    file, err := os.Create(tmpFilePath)
    if err != nil {
        return "", fmt.Errorf("创建临时文件失败: %w", err)
    }
    // 使用 defer 确保文件句柄在函数返回前关闭
    defer func() {
        if closeErr := file.Close(); closeErr != nil && err == nil {
            err = fmt.Errorf("关闭文件失败: %w", closeErr)
        }
    }()

    // 3. 写入数据到临时文件
    if _, writeErr := file.Write(d.Data); writeErr != nil {
        // 写入失败，尝试清理临时文件
        os.Remove(tmpFilePath) // 忽略清理错误
        return "", fmt.Errorf("写入数据失败: %w", writeErr)
    }

    // 4. 强制将数据同步到物理存储，确保持久性
    if syncErr := file.Sync(); syncErr != nil {
        // 同步失败，尝试清理临时文件
        os.Remove(tmpFilePath) // 忽略清理错误
        return "", fmt.Errorf("同步文件到磁盘失败: %w", syncErr)
    }

    // 5. 关闭文件（defer 会处理）
    // file.Close()

    // 6. 原子性重命名临时文件到最终目标，确保原子性
    finalFilePath := d.File()
    if renameErr := os.Rename(tmpFilePath, finalFilePath); renameErr != nil {
        // 重命名失败，清理临时文件
        os.Remove(tmpFilePath) // 忽略清理错误
        return "", fmt.Errorf("重命名文件失败: %w", renameErr)
    }

    return d.Hash, nil
}

func main() {
    // 示例用法
    data1 := []byte("Hello, GoLang data store!")
    doc1 := NewDocument(data1)
    hash1, err1 := doc1.Save()
    if err1 != nil {
        fmt.Printf("保存文档1失败: %v\n", err1)
    } else {
        fmt.Printf("文档1保存成功，哈希: %s\n", hash1)
        // 验证文件是否存在
        content, readErr := ioutil.ReadFile(doc1.File())
        if readErr != nil {
            fmt.Printf("读取文档1失败: %v\n", readErr)
        } else {
            fmt.Printf("读取到的内容: %s\n", string(content))
        }
    }

    data2 := []byte("Another piece of important data.")
    doc2 := NewDocument(data2)
    hash2, err2 := doc2.Save()
    if err2 != nil {
        fmt.Printf("保存文档2失败: %v\n", err2)
    } else {
        fmt.Printf("文档2保存成功，哈希: %s\n", hash2)
    }

    // 清理示例数据
    // os.RemoveAll("data")
}