GoFly框架中集成BoltDB和badferDB两个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.函数名 方式。比方：

1. // 获取桶中数据列表
2. func (t *Kv) List(offset, limit int) ([][]byte, error) {
3.     return plugin.Storager.List(t.key(""), offset, limit)
4. }
6. // 获取数据
7. func (t *Kv) Get(key string) ([]byte, error) {
8.     return plugin.Storager.Get(t.key(key))
9. }
11. // 保存数据
12. func (t *Kv) Set(key string, val []byte) error {
13.     return plugin.Storager.Set(t.key(key), val)
14. }
16. // 删除桶中的key
17. func (t *Kv) Delete(key string) error {
18.     return plugin.Storager.Delete(t.key(key))
19. }
21. // 删除桶
22. func (t *Kv) DeleteBucket() error {
23.     return plugin.Storager.DeleteBucket(t.key(""))
24. }
25. // 设置可以名称
26. func (t *Kv) key(key string) string {
27.     return "kv/" + key
28. }

复制代码

此中func (t *Kv) key(key string) string {}是设置key名称字符串。封装是约定传key是把桶和key用/拼接的字符串。调用是接口拿到字符串后分析拿到桶名和key名称。
5.接口调用示例代码

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

1. package storage
3. import (
4.     "encoding/json"
5.     "gofly/utils/gf"
6.     "gofly/utils/plugin"
7.     "time"
8. )
10. type User struct {
11.     NoNeedLogin []string //忽略登录接口配置-忽略全部传[*]
12.     NoNeedAuths []string //忽略登录接口配置-忽略全部传[*]
13. }
15. // 定义用户数据结构体
16. type UserData struct {
17.     ID        string    `json:"_id"`
18.     Name      string    `json:"name"`
19.     Role      string    `json:"role"`
20.     Salt      string    `json:"salt,omitempty"`
21.     Password  string    `json:"password,omitempty"`
22.     CreatedAt time.Time `json:"created_at"`
23. }
25. // 初始化路由
26. func init() {
27.     fpath := User{NoNeedLogin: []string{"*"}, NoNeedAuths: []string{"*"}}
28.     gf.Register(&fpath, fpath)
29. }
31. // 创建数据
32. func (api *User) AddData(c *gf.GinCtx) {
33.     param, _ := gf.RequestParam(c)
34.     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()})
35.     gf.Success().SetMsg("创建数据成功").SetData(red).Regin(c)
36. }
38. // 获取数据
39. func (api *User) GetData(c *gf.GinCtx) {
40.     id := c.DefaultQuery("id", "")
41.     if id == "" {
42.         gf.Failed().SetMsg("参数id不能为空").Regin(c)
43.         return
44.     }
45.     data, err := api.Get(id)
46.     if err != nil {
47.         gf.Failed().SetMsg(err.Error()).Regin(c)
48.         return
49.     }
50.     gf.Success().SetMsg("获取数据成功").SetData(data).Regin(c)
51. }
53. // 删除字段数据
54. func (api *User) DeleteData(c *gf.GinCtx) {
55.     param, _ := gf.RequestParam(c)
56.     if _, ok := param["id"]; !ok {
57.         gf.Failed().SetMsg("参数id不能为空").Regin(c)
58.         return
59.     }
60.     err := api.Delete(gf.String(param["id"]))
61.     if err != nil {
62.         gf.Failed().SetMsg(err.Error()).Regin(c)
63.         return
64.     }
65.     gf.Success().SetMsg("删除字段数据成功").Regin(c)
66. }
68. // 删除桶
69. func (api *User) DelBucket(c *gf.GinCtx) {
70.     err := api.DeleteBucket()
71.     if err != nil {
72.         gf.Failed().SetMsg(err.Error()).Regin(c)
73.         return
74.     }
75.     gf.Success().SetMsg("删除桶成功").Regin(c)
76. }
78. // 获取数据列表
79. func (api *User) GetList(c *gf.GinCtx) {
80.     offset := gf.Int(c.DefaultQuery("offset", "0"))
81.     pageSize := gf.Int(c.DefaultQuery("pageSize", "10"))
82.     list, err := api.List(offset, pageSize)
83.     if err != nil {
84.         gf.Failed().SetMsg(err.Error()).Regin(c)
85.         return
86.     }
87.     gf.Success().SetMsg("获取数据列表").SetData(list).Regin(c)
88. }
90. // 操作基础
91. func (t *User) List(offset, limit int) ([]*UserData, error) {
92.     data, err := plugin.Storager.List(t.key(""), offset, limit)
93.     if err != nil {
94.         return nil, err
95.     }
96.     users := make([]*UserData, 0, len(data))
97.     for _, d := range data {
98.         u := new(UserData)
99.         err = json.Unmarshal(d, u)
100.         if err != nil {
101.             return nil, err
102.         }
103.         users = append(users, u)
104.     }
105.     return users, nil
106. }
108. func (t *User) Get(id string) (*UserData, error) {
109.     data, err := plugin.Storager.Get(t.key(id))
110.     if err != nil {
111.         return nil, err
112.     }
113.     u := new(UserData)
114.     err = json.Unmarshal(data, u)
115.     return u, err
116. }
118. func (t *User) Set(id string, val UserData) error {
119.     data, err := json.Marshal(val)
120.     if err != nil {
121.         return err
122.     }
123.     return plugin.Storager.Set(t.key(id), data)
124. }
126. // 删除桶中key
127. func (t *User) Delete(id string) error {
128.     return plugin.Storager.Delete(t.key(id))
129. }
131. // 删除桶
132. func (t *User) DeleteBucket() error {
133.     return plugin.Storager.DeleteBucket(t.key(""))
134. }
136. // 组装key包含桶名和用户的id
137. func (t *User) key(id string) string {
138.     return "user/" + id
139. }

复制代码

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. 焦点特点

• LSM-Tree 架构：
  

• 写入先写入内存表（MemTable），再异步归并到磁盘（SSTable），得当高吞吐写入。
  
• 数据按层级归并（Compaction），自动优化存储结构。
  

• 键值分离（可选）：
  

• 大 Value 单独存储，淘汰 LSM-Tree 内部碎片，提拔查询服从。
  

• ACID 事件：
  

• 支持快照隔离（Snapshot Isolation），包管事件划一性。
  

• 低耽误读取：
  

• 内存缓存热门数据，团结布隆过滤器（Bloom Filter）加速查询。
  

• 跨平台：纯 Go 实现，无外部依赖，支持 Linux/macOS/Windows。
  

2. 实用场景

• 高频写入场景：日志收罗、实时指标存储、时序数据（如 IoT 装备数据）。
  
• 大 Value 存储：文档、图片等二进制数据（需开启键值分离）。
  
• 高并发读：缓存体系、元数据索引。
  
• 替换 LevelDB/RocksDB：需 Go 原生集成且无需 CGO 的场景。
  

​