深入理解Gorilla Sessions：利用自定义后端实现灵活会话管理

type Store interface {
    // Get returns a session for the given name after a request.
    //
    // The session store should also take care of deleting expired sessions.
    Get(r *http.Request, name string) (*Session, error)

    // New returns a new session for the given name without saving it.
    //
    // The session store should also take care of deleting expired sessions.
    New(r *http.Request, name string) (*Session, error)

    // Save saves all sessions used during the current request.
    Save(r *http.Request, w http.ResponseWriter, session *Session) error
}

package main

import (
    "encoding/gob"
    "net/http"
    "time"

    "github.com/garyburd/redigo/redis" // 推荐的Redis客户端库
    "github.com/gorilla/sessions"
)

// RedisStore 实现了 Gorilla Sessions 的 Store 接口
type RedisStore struct {
    Pool *redis.Pool
    Codecs []sessions.Codec
    Options *sessions.Options // 默认的会话选项
    KeyPrefix string // Redis 键前缀
}

// NewRedisStore 创建一个新的 RedisStore 实例
func NewRedisStore(pool *redis.Pool, keyPrefix string, keyPairs ...[]byte) *RedisStore {
    // 注册需要存储在会话中的自定义类型
    gob.Register(time.Time{})

    return &RedisStore{
        Pool:      pool,
        Codecs:    sessions.NewCookieStore(keyPairs...).Codecs, // 使用 CookieStore 的编码器
        Options:   &sessions.Options{
            Path:     "/",
            MaxAge:   86400 * 7, // 7天
            HttpOnly: true,
            Secure:   false, // 生产环境应设为 true
        },
        KeyPrefix: keyPrefix,
    }
}

// Get 从 Redis 中获取会话
func (s *RedisStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    return sessions.GetRegistry().Get(s, name, r)
}

// New 创建一个新的会话
func (s *RedisStore) New(r *http.Request, name string) (*sessions.Session, error) {
    session := sessions.NewSession(s, name)
    session.Options = s.Options
    session.IsNew = true // 标记为新会话

    // 尝试从 Cookie 中获取会话 ID，如果存在则尝试从 Redis 加载
    cookie, err := r.Cookie(name)
    if err == nil {
        id, err := sessions.DecodeMulti(name, cookie.Value, s.Codecs...)
        if err == nil {
            conn := s.Pool.Get()
            defer conn.Close()

            data, err := redis.Bytes(conn.Do("GET", s.KeyPrefix+id.(string)))
            if err == nil {
                if err = sessions.Decode(name, string(data), session); err == nil {
                    session.IsNew = false
                }
            }
        }
    }
    return session, nil
}

// Save 将会话保存到 Redis
func (s *RedisStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
    // 设置会话过期时间
    if session.Options.MaxAge > 0 {
        session.Values["_expires"] = time.Now().Add(time.Duration(session.Options.MaxAge) * time.Second)
    } else if session.Options.MaxAge < 0 {
        session.Values["_expires"] = time.Now().Add(365 * 24 * time.Hour) // 永不过期 (约一年)
    }

    // 编码会话数据
    encoded, err := sessions.Encode(session.Name(), session)
    if err != nil {
        return err
    }

    conn := s.Pool.Get()
    defer conn.Close()

    // 生成会话 ID
    if session.ID == "" {
        session.ID = sessions.NewUUID() // 或者其他唯一ID生成方式
    }

    // 保存到 Redis
    _, err = conn.Do("SETEX", s.KeyPrefix+session.ID, session.Options.MaxAge, encoded)
    if err != nil {
        return err
    }

    // 将会话 ID 写入 Cookie
    http.SetCookie(w, sessions.NewCookie(session.Name(), session.ID, session.Options))
    return nil
}

// 实际应用中，需要初始化 Redis 连接池
func initRedisPool() *redis.Pool {
    return &redis.Pool{
        MaxIdle:     3,
        IdleTimeout: 240 * time.Second,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", "localhost:6379") // 根据实际情况修改 Redis 地址
            if err != nil {
                return nil, err
            }
            // if _, err := c.Do("AUTH", "your_redis_password"); err != nil { // 如果 Redis 有密码
            //  c.Close()
            //  return nil, err
            // }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
    }
}

// 示例用法
func main() {
    pool := initRedisPool()
    defer pool.Close()

    // 创建 RedisStore 实例，使用随机密钥对加密会话 ID
    store := NewRedisStore(pool, "session:", []byte("super-secret-key"))

    // 注册一个处理器
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        session, err := store.Get(r, "my-session")
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // 获取或设置会话值
        if name, ok := session.Values["name"]; ok {
            w.Write([]byte("Hello, " + name.(string)))
        } else {
            session.Values["name"] = "Guest"
            session.Values["count"] = 1
            w.Write([]byte("Welcome, new user!"))
        }

        // 保存会话
        err = session.Save(r, w)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
    })

    http.ListenAndServe(":8080", nil)
}