使用Gorilla Sessions自定义后端实现Redis会话管理

type Store interface {
    Get(r *http.Request, name string) (*Session, error)
    New(r *http.Request, name string) (*Session, error)
    Save(r *http.Request, w http.ResponseWriter, s *Session) error
}

package main

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

    "github.com/garyburd/redigo/redis"
    "github.com/gorilla/sessions"
)

// RedisStore 实现了 sessions.Store 接口
type RedisStore struct {
    pool *redis.Pool
    keyPrefix string // Redis key 的前缀，避免冲突
    maxAge int // 会话最大有效期 (秒)
    cookieName string // Cookie 的名称
}

// NewRedisStore 创建一个新的 RedisStore
func NewRedisStore(pool *redis.Pool, keyPrefix string, maxAge int, cookieName string) *RedisStore {
    // 注册会话值类型，以便gob编码
    gob.Register(map[string]interface{}{})
    return &RedisStore{
        pool: pool,
        keyPrefix: keyPrefix,
        maxAge: maxAge,
        cookieName: cookieName,
    }
}

// Get 从 Redis 获取会话
func (s *RedisStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    // 1. 从 HTTP 请求中获取会话 ID (通常从 Cookie)
    // 2. 根据会话 ID 构造 Redis key
    // 3. 从 Redis 获取会话数据
    // 4. 反序列化数据到 sessions.Session
    // 5. 返回会话
    // ... 实际实现需要处理错误、会话不存在等情况
    session := sessions.NewSession(s, name)
    session.IsNew = true // 假设是新会话，直到从Redis加载成功

    cookie, err := r.Cookie(s.cookieName)
    if err != nil {
        return session, nil // 没有Cookie，返回新会话
    }

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

    key := s.keyPrefix + cookie.Value
    data, err := redis.Bytes(conn.Do("GET", key))
    if err != nil {
        if err == redis.ErrNil {
            return session, nil // Redis中不存在，返回新会话
        }
        return nil, err
    }

    // 反序列化数据
    err = sessions.Decode(cookie.Value, data, session) // 使用会话ID作为编码密钥
    if err != nil {
        return nil, err
    }
    session.IsNew = false
    return session, nil
}

// New 创建一个新的会话
func (s *RedisStore) New(r *http.Request, name string) (*sessions.Session, error) {
    session := sessions.NewSession(s, name)
    session.Options = &sessions.Options{
        Path:     "/",
        MaxAge:   s.maxAge,
        HttpOnly: true,
    }
    session.IsNew = true
    return session, nil
}

// Save 将会话保存到 Redis
func (s *RedisStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
    // 1. 序列化 sessions.Session 到字节数组
    // 2. 根据会话 ID 构造 Redis key
    // 3. 将数据存储到 Redis，并设置过期时间
    // 4. 设置会话 ID 到 HTTP 响应的 Cookie 中
    // ... 实际实现需要处理错误

    // 如果是新会话，生成一个新的会话 ID
    if session.IsNew {
        session.ID = sessions.NewSessionID() // 或自定义ID生成方式
    }

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

    // 序列化会话数据
    encoded, err := sessions.Encode(session.ID, session) // 使用会话ID作为编码密钥
    if err != nil {
        return err
    }

    key := s.keyPrefix + session.ID
    _, err = conn.Do("SETEX", key, s.maxAge, encoded) // 设置过期时间
    if err != nil {
        return err
    }

    // 设置 Cookie
    http.SetCookie(w, sessions.NewCookie(s.cookieName, session.ID, session.Options))
    return nil
}

// 实际应用中，还需要一个函数来初始化 Redis 连接池
func newRedisPool(addr string) *redis.Pool {
    return &redis.Pool{
        MaxIdle:     3,
        IdleTimeout: 240 * time.Second,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", addr)
            if err != nil {
                return nil, err
            }
            // if _, err := c.Do("AUTH", password); err != nil {
            //  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() {
    // 假设 Redis 运行在 localhost:6379
    redisPool := newRedisPool("localhost:6379")
    defer redisPool.Close()

    // 初始化 RedisStore
    store := NewRedisStore(redisPool, "my_app_session:", 3600, "my-session") // 会话有效期1小时

    // 使用 Gorilla Sessions
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        session, err := store.Get(r, "hello-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.Save(r, w) // 保存会话
            w.Write([]byte("Welcome, new guest!"))
        }
    })

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