GoFly框架中集成Bolt 和badfer两个Go语言嵌入式键值数据库

本插件集成了Bolt 和badfer两个纯Go实现的快速的嵌入式K/V数据库，方便开发时本地存储使用。插件集成Bolt 和badfer两个，如果确定使用其中一个，也可以把其中不用的一个删除，不删除也不会有任何影响。

插件使用说明

1.安装插件

到busines后台的开发者工具下的代码仓找到“Go语言嵌入式键值数据库”进行安装即可

2.代码说明

插件安装到utils\plugin目录中，其中在app\business\storage中有两个调用演示文件，一个是kv的字符串形式数据，一个是user用户对象信息json数据。

3.配置说明

在utils\plugin\storage\config\config.go的配置文件有两个参数，DataPath是创建的数据库文件存放位置，MetadataStorage是使用Bolt或者是badfer，默认是bolt。

4.如何调用

调用直接 plugin.Storager.函数名方式。例如：

// 获取桶中数据列表
func (t *Kv) List(offset, limit int) ([][]byte, error) {
    return plugin.Storager.List(t.key(""), offset, limit)
}

// 获取数据
func (t *Kv) Get(key string) ([]byte, error) {
    return plugin.Storager.Get(t.key(key))
}

// 保存数据
func (t *Kv) Set(key string, val []byte) error {
    return plugin.Storager.Set(t.key(key), val)
}

// 删除桶中的key
func (t *Kv) Delete(key string) error {
    return plugin.Storager.Delete(t.key(key))
}

// 删除桶
func (t *Kv) DeleteBucket() error {
    return plugin.Storager.DeleteBucket(t.key(""))
}
// 设置可以名称
func (t *Kv) key(key string) string {
    return "kv/" + key
}

其中func (t *Kv) key(key string) string {}是配置key名称字符串。封装是约定传key是把桶和key用/拼接的字符串。调用是接口拿到字符串后解析拿到桶名和key名称。

5.接口调用示例代码

这是安装插件后端再app\business\storage\user.go得到演示代码，在开发时你可以参数使用，完整代码如下：

package storage

import (
    "encoding/json"
    "gofly/utils/gf"
    "gofly/utils/plugin"
    "time"
)

type User struct {
    NoNeedLogin []string //忽略登录接口配置-忽略全部传[*]
    NoNeedAuths []string //忽略登录接口配置-忽略全部传[*]
}

// 定义用户数据结构体
type UserData struct {
    ID        string    `json:"_id"`
    Name      string    `json:"name"`
    Role      string    `json:"role"`
    Salt      string    `json:"salt,omitempty"`
    Password  string    `json:"password,omitempty"`
    CreatedAt time.Time `json:"created_at"`
}

// 初始化路由
func init() {
    fpath := User{NoNeedLogin: []string{"*"}, NoNeedAuths: []string{"*"}}
    gf.Register(&fpath, fpath)
}

// 创建数据
func (api *User) AddData(c *gf.GinCtx) {
    param, _ := gf.RequestParam(c)
    red := api.Set(gf.String(param["id"]), UserData{ID: gf.String(param["id"]), Name: gf.String(param["name"]), Role: gf.String(param["role"]), CreatedAt: time.Now()})
    gf.Success().SetMsg("创建数据成功").SetData(red).Regin(c)
}

// 获取数据
func (api *User) GetData(c *gf.GinCtx) {
    id := c.DefaultQuery("id", "")
    if id == "" {
        gf.Failed().SetMsg("参数id不能为空").Regin(c)
        return
    }
    data, err := api.Get(id)
    if err != nil {
        gf.Failed().SetMsg(err.Error()).Regin(c)
        return
    }
    gf.Success().SetMsg("获取数据成功").SetData(data).Regin(c)
}

// 删除字段数据
func (api *User) DeleteData(c *gf.GinCtx) {
    param, _ := gf.RequestParam(c)
    if _, ok := param["id"]; !ok {
        gf.Failed().SetMsg("参数id不能为空").Regin(c)
        return
    }
    err := api.Delete(gf.String(param["id"]))
    if err != nil {
        gf.Failed().SetMsg(err.Error()).Regin(c)
        return
    }
    gf.Success().SetMsg("删除字段数据成功").Regin(c)
}

// 删除桶
func (api *User) DelBucket(c *gf.GinCtx) {
    err := api.DeleteBucket()
    if err != nil {
        gf.Failed().SetMsg(err.Error()).Regin(c)
        return
    }
    gf.Success().SetMsg("删除桶成功").Regin(c)
}

// 获取数据列表
func (api *User) GetList(c *gf.GinCtx) {
    offset := gf.Int(c.DefaultQuery("offset", "0"))
    pageSize := gf.Int(c.DefaultQuery("pageSize", "10"))
    list, err := api.List(offset, pageSize)
    if err != nil {
        gf.Failed().SetMsg(err.Error()).Regin(c)
        return
    }
    gf.Success().SetMsg("获取数据列表").SetData(list).Regin(c)
}

// 操作基础
func (t *User) List(offset, limit int) ([]*UserData, error) {
    data, err := plugin.Storager.List(t.key(""), offset, limit)
    if err != nil {
        return nil, err
    }
    users := make([]*UserData, 0, len(data))
    for _, d := range data {
        u := new(UserData)
        err = json.Unmarshal(d, u)
        if err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, nil
}

func (t *User) Get(id string) (*UserData, error) {
    data, err := plugin.Storager.Get(t.key(id))
    if err != nil {
        return nil, err
    }
    u := new(UserData)
    err = json.Unmarshal(data, u)
    return u, err
}

func (t *User) Set(id string, val UserData) error {
    data, err := json.Marshal(val)
    if err != nil {
        return err
    }
    return plugin.Storager.Set(t.key(id), data)
}

// 删除桶中key
func (t *User) Delete(id string) error {
    return plugin.Storager.Delete(t.key(id))
}

// 删除桶
func (t *User) DeleteBucket() error {
    return plugin.Storager.DeleteBucket(t.key(""))
}

// 组装key包含桶名和用户的id
func (t *User) key(id string) string {
    return "user/" + id
}

BoltDB 介绍

BoltDB 是一个用 Go 语言编写的 嵌入式键值对数据库，基于 LMDB（Lightning Memory-Mapped Database）设计，专注于高性能和简单性。它无需独立服务，直接嵌入到应用程序中，适合单机场景，支持 ACID 事务。

1. 核心特点

键值存储：数据以 []byte 格式存储，支持嵌套 Bucket（类似命名空间）。
事务性：提供完整的 ACID 事务（读/写隔离），支持并发读，写操作串行化。
零依赖：纯 Go 实现，无需外部服务或依赖库。
内存映射：通过内存映射文件提升读取性能，写入通过 COW（写时复制）保证数据安全。
B+树索引：数据按字典序排序，支持范围查询和前缀扫描。

2. 适用场景

小型到中型单机应用（如配置文件、缓存、会话存储）。
需要高可靠性的本地数据持久化（如 IoT 设备、桌面应用）。
Go 生态项目快速集成轻量级存储。

BoltDB 是 Go 生态中轻量级、高可靠的嵌入式存储方案，适合需要简单事务和本地持久化的场景，但需权衡其单机写入瓶颈和内存限制。

BadgerDB 介绍

BadgerDB 是一个用 Go 语言编写的高性能键值对数据库，基于 LSM-Tree（Log-Structured Merge-Tree） 设计，专为高吞吐量写入和低延迟读取场景优化。与 BoltDB 不同，BadgerDB 通过混合内存与磁盘存储，支持海量数据的高效存取，同时保持 ACID 事务特性。

1. 核心特点