Golang最佳键值存储方案推荐

在Go中实现高性能键值存储并支持快速搜索，推荐以下方案：

1. BadgerDB - 最佳选择

基于LSM树的持久化键值存储，适合需要持久化和快速范围查询的场景。

package main

import (
    "fmt"
    "log"
    "github.com/dgraph-io/badger/v3"
)

func main() {
    // 打开数据库
    opts := badger.DefaultOptions("").WithInMemory(true)
    db, err := badger.Open(opts)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    // 写入数据
    err = db.Update(func(txn *badger.Txn) error {
        return txn.Set([]byte("user:1001"), []byte(`{"name":"Alice","age":30}`))
    })
    
    // 读取数据
    err = db.View(func(txn *badger.Txn) error {
        item, err := txn.Get([]byte("user:1001"))
        if err != nil {
            return err
        }
        val, err := item.ValueCopy(nil)
        fmt.Printf("Value: %s\n", val)
        return nil
    })
    
    // 前缀搜索
    err = db.View(func(txn *badger.Txn) error {
        it := txn.NewIterator(badger.DefaultIteratorOptions)
        defer it.Close()
        
        prefix := []byte("user:")
        for it.Seek(prefix); it.ValidForPrefix(prefix); it.Next() {
            item := it.Item()
            val, _ := item.ValueCopy(nil)
            fmt.Printf("Key: %s, Value: %s\n", item.Key(), val)
        }
        return nil
    })
}

2. BoltDB/BBolt - 简单可靠

纯Go实现的嵌入式键值存储，支持事务和桶结构。

package main

import (
    "fmt"
    "log"
    "go.etcd.io/bbolt"
)

func main() {
    // 打开数据库
    db, err := bbolt.Open("my.db", 0600, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    // 创建桶并写入数据
    err = db.Update(func(tx *bbolt.Tx) error {
        b, err := tx.CreateBucketIfNotExists([]byte("users"))
        if err != nil {
            return err
        }
        return b.Put([]byte("1001"), []byte("Alice"))
    })
    
    // 范围查询
    err = db.View(func(tx *bbolt.Tx) error {
        b := tx.Bucket([]byte("users"))
        c := b.Cursor()
        
        // 从特定键开始搜索
        for k, v := c.Seek([]byte("1000")); k != nil; k, v = c.Next() {
            fmt.Printf("key=%s, value=%s\n", k, v)
        }
        return nil
    })
}

3. Pebble - CockroachDB出品

高性能LSM树存储引擎，特别适合需要高吞吐量的场景。

package main

import (
    "fmt"
    "github.com/cockroachdb/pebble"
)

func main() {
    // 打开数据库
    db, err := pebble.Open("test", &pebble.Options{})
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 批量写入
    batch := db.NewBatch()
    batch.Set([]byte("key1"), []byte("value1"), nil)
    batch.Set([]byte("key2"), []byte("value2"), nil)
    batch.Commit(nil)
    
    // 前缀迭代器搜索
    iter, _ := db.NewIter(&pebble.IterOptions{
        LowerBound: []byte("key"),
        UpperBound: []byte("key\xff"),
    })
    defer iter.Close()
    
    for iter.First(); iter.Valid(); iter.Next() {
        fmt.Printf("Key: %s, Value: %s\n", iter.Key(), iter.Value())
    }
}

4. 内存存储 + 索引 - 纯内存方案

如果需要极致性能且数据可放入内存，可结合map和辅助索引。

package main

import (
    "fmt"
    "sync"
)

type IndexedStore struct {
    mu    sync.RWMutex
    data  map[string]interface{}
    index map[string][]string // 字段值 -> 键列表
}

func NewIndexedStore() *IndexedStore {
    return &IndexedStore{
        data:  make(map[string]interface{}),
        index: make(map[string][]string),
    }
}

func (s *IndexedStore) Set(key string, value map[string]string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    
    s.data[key] = value
    
    // 构建索引
    for field, fieldValue := range value {
        indexKey := fmt.Sprintf("%s:%s", field, fieldValue)
        s.index[indexKey] = append(s.index[indexKey], key)
    }
}

func (s *IndexedStore) Search(field, value string) []interface{} {
    s.mu.RLock()
    defer s.mu.RUnlock()
    
    indexKey := fmt.Sprintf("%s:%s", field, value)
    keys, exists := s.index[indexKey]
    if !exists {
        return nil
    }
    
    results := make([]interface{}, 0, len(keys))
    for _, key := range keys {
        results = append(results, s.data[key])
    }
    return results
}

func main() {
    store := NewIndexedStore()
    
    // 存储结构化数据
    store.Set("user1", map[string]string{
        "name": "Alice",
        "city": "New York",
        "role": "admin",
    })
    
    store.Set("user2", map[string]string{
        "name": "Bob",
        "city": "London",
        "role": "user",
    })
    
    // 快速搜索
    results := store.Search("city", "London")
    fmt.Printf("Users in London: %v\n", results)
}

选择建议：

• 需要持久化+高性能搜索：BadgerDB
• 简单事务需求：BoltDB
• 极高吞吐量：Pebble
• 纯内存+复杂查询：自定义索引结构

所有方案都支持基于前缀的范围查询，这是实现快速搜索的关键特性。BadgerDB的LSM树结构特别适合写密集和范围查询场景，而BoltDB的B+树结构在随机读取方面表现更好。