session

session 中间件为 Flame 实例提供用户会话管理服务，支持的存储后端包括内存、文件系统、PostgreSQL、MySQL、Redis 和 MongoDB。

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

下载安装

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

  1. go get github.com/flamego/session

存储后端

注意

本小结仅展示 session 中间件的相关用法，示例中的用户验证方案绝不可以直接被用于生产环境。

内存

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

  1. package main
  3. import (
  4.     "strconv"
  6.     "github.com/flamego/flamego"
  7.     "github.com/flamego/session"
  8. )
  10. func main() {
  11.     f := flamego.Classic()
  12.     f.Use(session.Sessioner())
  13.     f.Get("/set", func(s session.Session) string {
  14.         s.Set("user_id", 123)
  15.         return "Succeed"
  16.     })
  17.     f.Get("/get", func(s session.Session) string {
  18.         userID, ok := s.Get("user_id").(int)
  19.         if !ok || userID <= 0 {
  20.             return "Not authenticated"
  21.         }
  22.         return "Authenticated as " + strconv.Itoa(userID)
  23.     })
  24.     f.Get("/clear", func(s session.Session) string {
  25.         s.Delete("user_id")
  26.         return "Cleared"
  27.     })
  28.     f.Run()
  29. }

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

文件系统

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

  1. package main
  3. import (
  4.     "os"
  5.     "path/filepath"
  6.     "strconv"
  8.     "github.com/flamego/flamego"
  9.     "github.com/flamego/session"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  14.     f.Use(session.Sessioner(
  15.         session.Options{
  16.             Initer: session.FileIniter(),
  17.             Config: session.FileConfig{
  18.                 RootDir: filepath.Join(os.TempDir(), "sessions"),
  19.             },
  20.         },
  21.     ))
  22.     f.Get("/set", func(s session.Session) string {
  23.         s.Set("user_id", 123)
  24.         return "Succeed"
  25.     })
  26.     f.Get("/get", func(s session.Session) string {
  27.         userID, ok := s.Get("user_id").(int)
  28.         if !ok || userID <= 0 {
  29.             return "Not authenticated"
  30.         }
  31.         return "Authenticated as " + strconv.Itoa(userID)
  32.     })
  33.     f.Get("/clear", func(s session.Session) string {
  34.         s.Delete("user_id")
  35.         return "Cleared"
  36.     })
  37.     f.Run()
  38. }

PostgreSQL

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

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/postgres"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     dsn := os.ExpandEnv("postgres://$PGUSER:$PGPASSWORD@$PGHOST:$PGPORT/$PGDATABASE?sslmode=$PGSSLMODE")
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: postgres.Initer(),
  19.             Config: postgres.Config{
  20.                 DSN:       dsn,
  21.                 Table:     "sessions",
  22.                 InitTable: true,
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

MySQL

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

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/mysql"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     dsn := os.ExpandEnv("$MYSQL_USER:$MYSQL_PASSWORD@tcp($MYSQL_HOST:$MYSQL_PORT)/$MYSQL_DATABASE?charset=utf8&parseTime=true")
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: mysql.Initer(),
  19.             Config: mysql.Config{
  20.                 DSN:       dsn,
  21.                 Table:     "cache",
  22.                 InitTable: true,
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

Redis

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

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/redis"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     f.Use(session.Sessioner(
  16.         session.Options{
  17.             Initer: redis.Initer(),
  18.             Config: redis.Config{
  19.                 Options: &redis.Options{
  20.                     Addr: os.ExpandEnv("$REDIS_HOST:$REDIS_PORT"),
  21.                     DB:   15,
  22.                 },
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

MongoDB

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

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/mongo"
  10.     "go.mongodb.org/mongo-driver/mongo/options"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: mongo.Initer(),
  19.             Config: mongo.Config{
  20.                 Options:    options.Client().ApplyURI(os.Getenv("MONGODB_URI")),
  21.                 Database:   os.Getenv("MONGODB_DATABASE"),
  22.                 Collection: "cache",
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

闪现消息

session 中间件提供了闪现消息的机制，闪现消息指的是在下次会话展现给用户的消息，并且只会展现一次。

闪现消息最简单的形式就是字符串：

  1. package main
  3. import (
  4.     "github.com/flamego/flamego"
  5.     "github.com/flamego/session"
  6. )
  8. func main() {
  9.     f := flamego.Classic()
  10.     f.Use(session.Sessioner())
  11.     f.Get("/set", func(s session.Session) string {
  12.         s.SetFlash("This is a flash message")
  13.         return "Succeed"
  14.     })
  15.     f.Get("/get", func(f session.Flash) string {
  16.         s, ok := f.(string)
  17.         if !ok || s == "" {
  18.             return "No flash message"
  19.         }
  20.         return s
  21.     })
  22.     f.Run()
  23. }

session.Flashsession - 图15在新窗口打开 是单纯作为闪现消息的载体而存在，你可以使用任意类型作为闪现消息的具体表现形式，且不同路由之间的闪现消息类型也可完全不同：

  1. package main
  3. import (
  4.     "fmt"
  6.     "github.com/flamego/flamego"
  7.     "github.com/flamego/session"
  8. )
  10. func main() {
  11.     f := flamego.Classic()
  12.     f.Use(session.Sessioner())
  14.     f.Get("/set-simple", func(s session.Session) string {
  15.         s.SetFlash("This is a flash message")
  16.         return "Succeed"
  17.     })
  18.     f.Get("/get-simple", func(f session.Flash) string {
  19.         s, ok := f.(string)
  20.         if !ok || s == "" {
  21.             return "No flash message"
  22.         }
  23.         return s
  24.     })
  26.     type Flash struct {
  27.         Success string
  28.         Error   string
  29.     }
  30.     f.Get("/set-complex", func(s session.Session) string {
  31.         s.SetFlash(Flash{
  32.             Success: "It worked!",
  33.         })
  34.         return "Succeed"
  35.     })
  36.     f.Get("/get-complex", func(f session.Flash) string {
  37.         s, ok := f.(Flash)
  38.         if !ok {
  39.             return "No flash message"
  40.         }
  41.         return fmt.Sprintf("%#v", s)
  42.     })
  43.     f.Run()
  44. }

上例展示了如何在不同的路由中使用不同类型的闪现消息（string and Flash）。