查询缓存

gdb支持对查询结果的缓存处理，常用于多读少写的查询缓存场景，并支持手动的缓存清理。需要注意的是，查询缓存仅支持链式操作，且在事务操作下不可用。

相关方法：

  1. type CacheOption struct {
  2.     // Duration is the TTL for the cache.
  3.     // If the parameter `Duration` < 0, which means it clear the cache with given `Name`.
  4.     // If the parameter `Duration` = 0, which means it never expires.
  5.     // If the parameter `Duration` > 0, which means it expires after `Duration`.
  6.     Duration time.Duration
  8.     // Name is an optional unique name for the cache.
  9.     // The Name is used to bind a name to the cache, which means you can later control the cache
  10.     // like changing the `duration` or clearing the cache with specified Name.
  11.     Name string
  13.     // Force caches the query result whatever the result is nil or not.
  14.     // It is used to avoid Cache Penetration.
  15.     Force bool
  16. }
  18. // Cache sets the cache feature for the model. It caches the result of the sql, which means
  19. // if there's another same sql request, it just reads and returns the result from cache, it
  20. // but not committed and executed into the database.
  21. //
  22. // Note that, the cache feature is disabled if the model is performing select statement
  23. // on a transaction.
  24. func (m *Model) Cache(option CacheOption) *Model

缓存对象

ORM对象默认情况下提供了缓存管理对象，该缓存对象类型为*gcache.Cache，也就是说同时也支持*gcache.Cache的所有特性。可以通过GetCache() *gcache.Cache 接口方法获得该缓存对象，并通过返回的对象实现自定义的各种缓存操作，例如：g.DB().GetCache().Keys()。

缓存适配（Redis缓存）

默认情况下ORM的*gcache.Cache缓存对象提供的是单进程内存缓存，虽然性能非常高效，但是只能在单进程内使用。如果服务如果采用多节点部署，多节点之间的缓存可能会产生数据不一致的情况，因此大多数场景下我们都是通过Redis服务器来实现对数据库查询数据的缓存。*gcache.Cache对象采用了适配器设计模式，可以轻松实现从单进程内存缓存切换为分布式的Redis缓存。使用示例：

  1. redisCache := gcache.NewAdapterRedis(g.Redis())
  2. g.DB().GetCache().SetAdapter(redisCache)

更多介绍请参考：缓存管理-Redis缓存

使用示例

数据表结构

  1. CREATE TABLE `user` (
  2.   `uid` int(10) unsigned NOT NULL AUTO_INCREMENT,
  3.   `name` varchar(30) NOT NULL DEFAULT '' COMMENT '昵称',
  4.   `site` varchar(255) NOT NULL DEFAULT '' COMMENT '主页',
  5.   PRIMARY KEY (`uid`)
  6. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

示例代码

  1. package main
  3. import (
  4.     "time"
  6.     "github.com/gogf/gf/v2/database/gdb"
  7.     "github.com/gogf/gf/v2/frame/g"
  8.     "github.com/gogf/gf/v2/os/gctx"
  9. )
  11. func main() {
  12.     var (
  13.         db  = g.DB()
  14.         ctx = gctx.New()
  15.     )
  17.     // 开启调试模式，以便于记录所有执行的SQL
  18.     db.SetDebug(true)
  20.     // 写入测试数据
  21.     _, err := db.Model("user").Ctx(ctx).Data(g.Map{
  22.         "name": "john",
  23.         "site": "https://goframe.org",
  24.     }).Insert()
  26.     // 执行2次查询并将查询结果缓存1小时，并可执行缓存名称(可选)
  27.     for i := 0; i < 2; i++ {
  28.         r, _ := db.Model("user").Ctx(ctx).Cache(gdb.CacheOption{
  29.             Duration: time.Hour,
  30.             Name:     "vip-user",
  31.             Force:    false,
  32.         }).Where("uid", 1).One()
  33.         g.Log().Debug(ctx, r.Map())
  34.     }
  36.     // 执行更新操作，并清理指定名称的查询缓存
  37.     _, err = db.Model("user").Ctx(ctx).Cache(gdb.CacheOption{
  38.         Duration: -1,
  39.         Name:     "vip-user",
  40.         Force:    false,
  41.     }).Data(gdb.Map{"name": "smith"}).Where("uid", 1).Update()
  42.     if err != nil {
  43.         g.Log().Fatal(ctx, err)
  44.     }
  46.     // 再次执行查询，启用查询缓存特性
  47.     r, _ := db.Model("user").Ctx(ctx).Cache(gdb.CacheOption{
  48.         Duration: time.Hour,
  49.         Name:     "vip-user",
  50.         Force:    false,
  51.     }).Where("uid", 1).One()
  52.     g.Log().Debug(ctx, r.Map())
  53. }

执行后输出结果为（测试表数据结构仅供示例参考）：

  1. 2022-02-08 17:36:19.817 [DEBU] {c0424c75f1c5d116d0df0f7197379412} {"name":"john","site":"https://goframe.org","uid":1} 
  2. 2022-02-08 17:36:19.817 [DEBU] {c0424c75f1c5d116d0df0f7197379412} {"name":"john","site":"https://goframe.org","uid":1} 
  3. 2022-02-08 17:36:19.817 [DEBU] {c0424c75f1c5d116d0df0f7197379412} [  0 ms] [default] [rows:1  ] UPDATE `user` SET `name`='smith' WHERE `uid`=1 
  4. 2022-02-08 17:36:19.818 [DEBU] {c0424c75f1c5d116d0df0f7197379412} [  1 ms] [default] [rows:1  ] SELECT * FROM `user` WHERE `uid`=1 LIMIT 1 
  5. 2022-02-08 17:36:19.818 [DEBU] {c0424c75f1c5d116d0df0f7197379412} {"name":"smith","site":"https://goframe.org","uid":1}

可以看到：

  1. 为了方便展示缓存效果，这里开启了数据debug特性，当有任何的SQL操作时将会输出到终端。
  2. 执行两次One方法数据查询，第一次走了SQL查询，第二次直接使用到了缓存，SQL没有提交到数据库执行，因此这里只打印了一条查询SQL，并且两次查询的结果也是一致的。
  3. 注意这里为该查询的缓存设置了一个自定义的名称vip-user，以便于后续清空更新缓存。如果缓存不需要清理，那么可以不用设置缓存名称。
  4. 当执行Update更新操作时，同时根据名称清空指定的缓存。
  5. 随后再执行One方法数据查询，这时重新缓存新的数据。