cache

The cache middleware provides cache data management for Flame instances, supporting various storage backends, including memory, file, PostgreSQL, MySQL, Redis and MongoDB.

You can read source code of this middleware on GitHubcache - 图1open in new window and API documentation on pkg.go.devcache - 图2open in new window.

Installation

The minimum requirement of Go is 1.16.

  1. go get github.com/flamego/cache

Storage backends

Memory

The cache.Cachercache - 图3open in new window works out-of-the-box with an optional cache.Optionscache - 图4open in new window and uses memory as the storage backend:

  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. }

Because the memory is volatile, cache data do not survive over restarts. Choose other storage backends if you need to persist cache data.

File

The cache.FileInitercache - 图5open in new window is the function to initialize a file storage backend, used together with cache.FileConfigcache - 图6open in new window to customize the backend:

  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

The postgres.Initercache - 图7open in new window is the function to initialize a PostgreSQL storage backend, used together with postgres.Configcache - 图8open in new window to customize the backend:

  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

The mysql.Initercache - 图9open in new window is the function to initialize a MySQL storage backend, used together with mysql.Configcache - 图10open in new window to customize the backend:

  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

The redis.Initercache - 图11open in new window is the function to initialize a Redis storage backend, used together with redis.Configcache - 图12open in new window to customize the backend:

  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

The mongo.Initercache - 图13open in new window is the function to initialize a MongoDB storage backend, used together with mongo.Configcache - 图14open in new window to customize the backend:

  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. }

Supported value types

The default encoder and decoder of cache data use gobcache - 图15open in new window, and only limited types are supported for values. When you encounter errors like encode: gob: type not registered for interface: time.Duration, you can use gob.Registercache - 图16open in new window to register the type for encoding and decoding.

For example:

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

You only need to regsiter once for the entire lifecyle of your application.