session

    You can read source code of this middleware on GitHubopen in new window and API documentation on .

    The minimum requirement of Go is 1.16.

    WARNING

    Examples included in this section is to demonstrate the usage of the session middleware, by no means illustrates the idiomatic or even correct way of doing user authentication.

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

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

    File

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

    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()

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

    MySQL

    The mysql.Initeropen in new window is the function to initialize a MySQL storage backend, used together with to customize the backend:

    1. package main
    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. }
    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.         return "Authenticated as " + strconv.Itoa(userID)
    36.     f.Get("/clear", func(s session.Session) string {
    37.         s.Delete("user_id")
    38.         return "Cleared"
    39.     })
    40.     f.Run()
    41. }

    MongoDB

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

    The session middleware provides a mechanism for flash messages, which are always retrieved on the next access of the same session, once and only once (i.e. flash messages get deleted upon retrievals).

    A flash message could just be a string in its simplest form:

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

    The is just the value holder of the flash message, and it could be any type that fits your application’s needs, and doesn’t even have to be the same type for different routes in the same application!

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