golang轻量级磁盘存储键值对插件库diskv的使用

Golang轻量级磁盘存储键值对插件库diskv的使用

什么是diskv?

Diskv (disk-vee) 是一个用Go语言编写的简单、持久的键值存储。它最初提供了一个极其简单的API，用于通过键在文件系统上存储任意数据，并在其上构建了多层性能增强的抽象。最终结果是一个概念上简单但性能很高的磁盘支持存储系统。

Build Status

安装

安装Go 1，然后执行：

$ go get github.com/peterbourgon/diskv/v3

使用示例

package main

import (
	"fmt"
	"github.com/peterbourgon/diskv/v3"
)

func main() {
	// 最简单的转换函数：将所有数据文件放入基础目录
	flatTransform := func(s string) []string { return []string{} }

	// 初始化一个新的diskv存储，根目录为"my-data-dir"，缓存大小为1MB
	d := diskv.New(diskv.Options{
		BasePath:     "my-data-dir",
		Transform:    flatTransform,
		CacheSizeMax: 1024 * 1024,
	})

	// 写入三个字节到键"alpha"
	key := "alpha"
	d.Write(key, []byte{'1', '2', '3'})

	// 从存储中读取值
	value, _ := d.Read(key)
	fmt.Printf("%v\n", value)

	// 从存储中删除键值对（以及磁盘上的文件）
	d.Erase(key)
}

基本概念

diskv的核心是一个键(string)到任意数据([]byte)的映射。数据被写入与键同名的单个文件中。键通过用户提供的TransformFunc确定文件存储位置，该函数接收一个键并返回一个路径列表([]string)。

最简单的TransformFunc：

func SimpleTransform (key string) []string {
    return []string{}
}

高级路径转换

如果需要更多控制文件名或支持键名中的斜杠或特殊字符，可以使用AdvancedTransform属性：

func AdvancedTransformExample(key string) *diskv.PathKey {
	path := strings.Split(key, "/")
	last := len(path) - 1
	return &diskv.PathKey{
		Path:     path[:last],
		FileName: path[last] + ".txt",
	}
}

// 必须提供反向转换函数
func InverseTransformExample(pathKey *diskv.PathKey) (key string) {
	txt := pathKey.FileName[len(pathKey.FileName)-4:]
	if txt != ".txt" {
		panic("Invalid file found in storage folder!")
	}
	return strings.Join(pathKey.Path, "/") + pathKey.FileName[:len(pathKey.FileName)-4]
}

func main() {
	d := diskv.New(diskv.Options{
		BasePath:          "my-data-dir",
		AdvancedTransform: AdvancedTransformExample,
		InverseTransform:  InverseTransformExample,
		CacheSizeMax:      1024 * 1024,
	})
	// 写入文本到键"alpha/beta/gamma"
	key := "alpha/beta/gamma"
	d.WriteString(key, "¡Hola!") // 将存储在"<basedir>/alpha/beta/gamma.txt"
	fmt.Println(d.ReadString("alpha/beta/gamma"))
}

其他特性

  • 缓存：通过将BasicStore功能与简单的map结构结合，并保持其更新，提供了一个内存缓存层
  • 排序：通过实现diskv.Index接口可以注入排序系统
  • 压缩：通过实现diskv.Compression接口可以在存储创建时传递压缩功能
  • 流式处理：diskv现在提供ReadStream和WriteStream方法，可以高效处理非常大的数据

未来计划

  • 需要大量健壮性测试：大数据集等…
  • 更彻底的基准测试
  • 用户建议的其他用例

作者和贡献者

原始想法、设计和实现：Peter Bourgon
其他合作者：Javier Peletier (Epic Labs)


更多关于golang轻量级磁盘存储键值对插件库diskv的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang轻量级磁盘存储键值对插件库diskv的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang轻量级磁盘存储键值对插件库diskv使用指南

diskv是一个简单高效的Golang键值存储库，它将数据直接存储在文件系统中，非常适合需要持久化键值对但不想引入复杂数据库系统的场景。

安装diskv

go get github.com/peterbourgon/diskv

基本使用

初始化diskv

package main

import (
	"fmt"
	"github.com/peterbourgon/diskv"
)

func main() {
	// 定义存储路径和转换函数
	d := diskv.New(diskv.Options{
		BasePath:     "my-diskv-data", // 存储目录
		Transform:    func(s string) []string { return []string{} }, // 键转换函数
		CacheSizeMax: 1024 * 1024, // 最大缓存大小(字节)
	})
	
	defer d.EraseAll() // 程序结束时清理
}

读写操作

// 写入数据
key := "user:1001"
value := []byte(`{"name":"张三","age":30}`)
if err := d.Write(key, value); err != nil {
    fmt.Printf("写入失败: %v\n", err)
}

// 读取数据
data, err := d.Read(key)
if err != nil {
    fmt.Printf("读取失败: %v\n", err)
} else {
    fmt.Printf("读取数据: %s\n", string(data))
}

// 检查键是否存在
has, err := d.Has(key)
if err != nil {
    fmt.Printf("检查存在失败: %v\n", err)
} else {
    fmt.Printf("键存在: %v\n", has)
}

// 删除键
if err := d.Erase(key); err != nil {
    fmt.Printf("删除失败: %v\n", err)
}

批量操作

// 批量写入
batch := []diskv.WriteBatchItem{
    {Key: "user:1002", Value: []byte(`{"name":"李四","age":25}`)},
    {Key: "user:1003", Value: []byte(`{"name":"王五","age":28}`)},
}

if err := d.WriteBatch(batch); err != nil {
    fmt.Printf("批量写入失败: %v\n", err)
}

// 遍历所有键
keys, err := d.Keys(nil)
if err != nil {
    fmt.Printf("获取键列表失败: %v\n", err)
} else {
    for _, key := range keys {
        fmt.Printf("键: %s\n", key)
    }
}

高级特性

自定义键路径转换

// 将键转换为多级目录结构
d := diskv.New(diskv.Options{
    BasePath: "my-diskv-data",
    Transform: func(s string) []string {
        // 例如将"user:1001"转换为["user","1001"]目录结构
        return strings.Split(s, ":")
    },
    CacheSizeMax: 1024 * 1024,
})

使用缓存

diskv内置了内存缓存机制，可以通过CacheSizeMax参数控制缓存大小：

d := diskv.New(diskv.Options{
    BasePath:     "my-diskv-data",
    Transform:    func(s string) []string { return []string{} },
    CacheSizeMax: 10 * 1024 * 1024, // 10MB缓存
})

压缩数据

import "compress/gzip"

// 写入时压缩
func writeCompressed(d *diskv.Diskv, key string, data []byte) error {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    if _, err := w.Write(data); err != nil {
        return err
    }
    if err := w.Close(); err != nil {
        return err
    }
    return d.Write(key, buf.Bytes())
}

// 读取时解压
func readCompressed(d *diskv.Diskv, key string) ([]byte, error) {
    data, err := d.Read(key)
    if err != nil {
        return nil, err
    }
    
    r, err := gzip.NewReader(bytes.NewReader(data))
    if err != nil {
        return nil, err
    }
    defer r.Close()
    
    return ioutil.ReadAll(r)
}

性能优化建议

  1. 合理设置缓存大小：根据应用场景调整CacheSizeMax参数
  2. 批量操作：尽可能使用WriteBatch进行批量写入
  3. 键设计：使用有意义的键前缀和转换函数来优化文件系统性能
  4. 定期维护：对于长期运行的应用，可以定期清理不再需要的数据

适用场景

diskv非常适合以下场景：

  • 需要简单持久化的键值存储
  • 不想引入外部数据库依赖
  • 数据量适中(GB级别以下)
  • 需要快速本地访问

对于更复杂的查询需求或TB级数据，建议考虑专门的数据库系统如BoltDB、Badger或SQLite。

diskv以其简单性和高效性成为Golang项目中轻量级持久化存储的优秀选择。

回到顶部