cache

cache 中间件为 Flame 实例提供缓存数据管理服务，支持的存储后端包括内存、文件系统、PostgreSQL、MySQL、Redis 和 MongoDB。

你可以在 GitHubcache - 图1在新窗口打开 上阅读该中间件的源码或通过 pkg.go.devcache - 图2在新窗口打开 查看 API 文档。

下载安装

Go 语言的最低版本要求为 1.16。

  1. go get github.com/flamego/cache

存储后端

内存

cache.Cachercache - 图3在新窗口打开 可以配合 cache.Optionscache - 图4在新窗口打开 对中间件进行配置，并默认使用内存作为存储后端：

  1. package main
  3. import (
  4.     "net/http"
  5.     "time"
  7.     "github.com/flamego/cache"
  8.     "github.com/flamego/flamego"
  9. )
  11. func main() {
  12.     f := flamego.Classic()
  13.     f.Use(cache.Cacher())
  14.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  15.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  16.     })
  17.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  18.         v, err := cache.Get(r.Context(), "cooldown")
  19.         if err != nil && err != os.ErrNotExist {
  20.             return err.Error()
  21.         }
  23.         cooldown, ok := v.(bool)
  24.         if !ok || !cooldown {
  25.             return "It has been cooled"
  26.         }
  27.         return "Still hot"
  28.     })
  29.     f.Run()
  30. }

由于数据存储在内存中，因此会在应用退出后被清除。如需持久化缓存数据，请选择其它存储后端。

文件系统

cache.FileInitercache - 图5在新窗口打开 是文件系统存储后端的初始化函数，并可以配合 cache.FileConfigcache - 图6在新窗口打开 对其进行配置：

  1. package main
  3. import (
  4.     "net/http"
  5.     "os"
  6.     "path/filepath"
  7.     "time"
  9.     "github.com/flamego/cache"
  10.     "github.com/flamego/flamego"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  15.     f.Use(cache.Cacher(
  16.         cache.Options{
  17.             Initer: cache.FileIniter(),
  18.             Config: cache.FileConfig{
  19.                 RootDir: filepath.Join(os.TempDir(), "cache"),
  20.             },
  21.         },
  22.     ))
  23.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  24.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  25.     })
  26.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  27.         v, err := cache.Get(r.Context(), "cooldown")
  28.         if err != nil && err != os.ErrNotExist {
  29.             return err.Error()
  30.         }
  32.         cooldown, ok := v.(bool)
  33.         if !ok || !cooldown {
  34.             return "It has been cooled"
  35.         }
  36.         return "Still hot"
  37.     })
  38.     f.Run()
  39. }

PostgreSQL

postgres.Initercache - 图7在新窗口打开 是 PostgreSQL 存储后端的初始化函数，并可以配合 postgres.Configcache - 图8在新窗口打开 对其进行配置：

  1. package main
  3. import (
  4.     "net/http"
  5.     "os"
  6.     "time"
  8.     "github.com/flamego/cache"
  9.     "github.com/flamego/cache/postgres"
  10.     "github.com/flamego/flamego"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  16.     dsn := os.ExpandEnv("postgres://$PGUSER:$PGPASSWORD@$PGHOST:$PGPORT/$PGDATABASE?sslmode=$PGSSLMODE")
  17.     f.Use(cache.Cacher(
  18.         cache.Options{
  19.             Initer: postgres.Initer(),
  20.             Config: postgres.Config{
  21.                 DSN:       dsn,
  22.                 Table:     "cache",
  23.                 InitTable: true,
  24.             },
  25.         },
  26.     ))
  27.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  28.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  29.     })
  30.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  31.         v, err := cache.Get(r.Context(), "cooldown")
  32.         if err != nil && err != os.ErrNotExist {
  33.             return err.Error()
  34.         }
  36.         cooldown, ok := v.(bool)
  37.         if !ok || !cooldown {
  38.             return "It has been cooled"
  39.         }
  40.         return "Still hot"
  41.     })
  42.     f.Run()
  43. }

MySQL

mysql.Initercache - 图9在新窗口打开 是 MySQL 存储后端的初始化函数，并可以配合 mysql.Configcache - 图10在新窗口打开 对其进行配置：

  1. package main
  3. import (
  4.     "net/http"
  5.     "os"
  6.     "time"
  8.     "github.com/flamego/cache"
  9.     "github.com/flamego/cache/mysql"
  10.     "github.com/flamego/flamego"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  16.     dsn := os.ExpandEnv("$MYSQL_USER:$MYSQL_PASSWORD@tcp($MYSQL_HOST:$MYSQL_PORT)/$MYSQL_DATABASE?charset=utf8&parseTime=true")
  17.     f.Use(cache.Cacher(
  18.         cache.Options{
  19.             Initer: mysql.Initer(),
  20.             Config: mysql.Config{
  21.                 DSN:       dsn,
  22.                 Table:     "cache",
  23.                 InitTable: true,
  24.             },
  25.         },
  26.     ))
  27.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  28.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  29.     })
  30.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  31.         v, err := cache.Get(r.Context(), "cooldown")
  32.         if err != nil && err != os.ErrNotExist {
  33.             return err.Error()
  34.         }
  36.         cooldown, ok := v.(bool)
  37.         if !ok || !cooldown {
  38.             return "It has been cooled"
  39.         }
  40.         return "Still hot"
  41.     })
  42.     f.Run()
  43. }

Redis

redis.Initercache - 图11在新窗口打开 是 Redis 存储后端的初始化函数，并可以配合 redis.Configcache - 图12在新窗口打开 对其进行配置：

  1. package main
  3. import (
  4.     "net/http"
  5.     "os"
  6.     "time"
  8.     "github.com/flamego/cache"
  9.     "github.com/flamego/cache/redis"
  10.     "github.com/flamego/flamego"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  16.     f.Use(cache.Cacher(
  17.         cache.Options{
  18.             Initer: redis.Initer(),
  19.             Config: redis.Config{
  20.                 Options: &redis.Options{
  21.                     Addr: os.ExpandEnv("$REDIS_HOST:$REDIS_PORT"),
  22.                     DB:   15,
  23.                 },
  24.             },
  25.         },
  26.     ))
  27.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  28.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  29.     })
  30.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  31.         v, err := cache.Get(r.Context(), "cooldown")
  32.         if err != nil && err != os.ErrNotExist {
  33.             return err.Error()
  34.         }
  36.         cooldown, ok := v.(bool)
  37.         if !ok || !cooldown {
  38.             return "It has been cooled"
  39.         }
  40.         return "Still hot"
  41.     })
  42.     f.Run()
  43. }

MongoDB

mongo.Initercache - 图13在新窗口打开 是 MongoDB 存储后端的初始化函数，并可以配合 mongo.Configcache - 图14在新窗口打开 对其进行配置：

  1. package main
  3. import (
  4.     "net/http"
  5.     "os"
  6.     "time"
  8.     "github.com/flamego/cache"
  9.     "github.com/flamego/cache/mongo"
  10.     "github.com/flamego/flamego"
  11.     "go.mongodb.org/mongo-driver/mongo/options"
  12. )
  14. func main() {
  15.     f := flamego.Classic()
  17.     f.Use(cache.Cacher(
  18.         cache.Options{
  19.             Initer: mongo.Initer(),
  20.             Config: mongo.Config{
  21.                 Options:    options.Client().ApplyURI(os.Getenv("MONGODB_URI")),
  22.                 Database:   os.Getenv("MONGODB_DATABASE"),
  23.                 Collection: "cache",
  24.             },
  25.         },
  26.     ))
  27.     f.Get("/set", func(r *http.Request, cache cache.Cache) error {
  28.         return cache.Set(r.Context(), "cooldown", true, time.Minute)
  29.     })
  30.     f.Get("/get", func(r *http.Request, cache cache.Cache) string {
  31.         v, err := cache.Get(r.Context(), "cooldown")
  32.         if err != nil && err != os.ErrNotExist {
  33.             return err.Error()
  34.         }
  36.         cooldown, ok := v.(bool)
  37.         if !ok || !cooldown {
  38.             return "It has been cooled"
  39.         }
  40.         return "Still hot"
  41.     })
  42.     f.Run()
  43. }

存储类型支持

缓存数据的默认编解码格式为 gobcache - 图15在新窗口打开，因此仅支持有限的值类型。如果遇到类似 encode: gob: type not registered for interface: time.Duration 这样的错误，则可以通过 gob.Registercache - 图16在新窗口打开 在应用中将该类型注册到编解码器中解决：

  1. gob.Register(time.Duration(0))

单个应用中对同一类型仅需注册一次。