Golang服务器会话状态设计模式探讨

在Go语言中，服务器会话状态设计通常有以下几种实现方式：

1. 内置支持方式

Go标准库通过http.Cookie和http.Request的Cookie方法提供基础会话支持：

// 设置会话cookie
func setSession(w http.ResponseWriter, r *http.Request) {
    expiration := time.Now().Add(24 * time.Hour)
    cookie := http.Cookie{
        Name:    "session_id",
        Value:   generateSessionID(),
        Expires: expiration,
        Path:    "/",
    }
    http.SetCookie(w, &cookie)
}

// 读取会话
func getSession(r *http.Request) (string, error) {
    cookie, err := r.Cookie("session_id")
    if err != nil {
        return "", err
    }
    return cookie.Value, nil
}

2. 使用gorilla/sessions包

gorilla/mux本身不直接提供会话管理，但gorilla/sessions是常用的会话管理库：

import (
    "github.com/gorilla/sessions"
    "net/http"
)

var store = sessions.NewCookieStore([]byte("your-secret-key"))

func handler(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "session-name")
    
    // 设置会话值
    session.Values["authenticated"] = true
    session.Values["user_id"] = 123
    
    // 保存会话
    err := session.Save(r, w)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    // 读取会话值
    if auth, ok := session.Values["authenticated"].(bool); ok && auth {
        // 用户已认证
    }
}

3. 使用上下文（Context）的请求级状态

对于REST API，使用context.Context传递请求级状态是推荐的做法：

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 验证token并获取用户信息
        userID, err := validateToken(r)
        if err != nil {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        
        // 将用户信息存入上下文
        ctx := context.WithValue(r.Context(), "user_id", userID)
        ctx = context.WithValue(ctx, "authenticated", true)
        
        // 使用新的上下文继续处理
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func protectedHandler(w http.ResponseWriter, r *http.Request) {
    // 从上下文中获取用户信息
    if userID, ok := r.Context().Value("user_id").(int); ok {
        fmt.Fprintf(w, "User ID: %d", userID)
    }
}

// 在gorilla/mux中使用
router := mux.NewRouter()
router.Use(authMiddleware)
router.HandleFunc("/protected", protectedHandler)

4. 服务器端会话存储

对于需要共享会话数据的分布式系统：

import (
    "github.com/go-redis/redis/v8"
    "github.com/gorilla/sessions"
    goredisstore "github.com/boj/redistore"
)

// 使用Redis存储会话
func createRedisStore() sessions.Store {
    store, err := goredisstore.NewRediStore(10, "tcp", "localhost:6379", "", []byte("secret-key"))
    if err != nil {
        panic(err)
    }
    return store
}

// 或者自定义存储
type CustomSessionStore struct {
    redisClient *redis.Client
}

func (s *CustomSessionStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    // 从Redis获取会话数据
    sessionID, _ := r.Cookie("session_id")
    data, err := s.redisClient.Get(r.Context(), sessionID.Value).Result()
    // ... 解析并返回会话
}

关于REST API和上下文的区别

在REST API中，使用context.Context传递请求级状态与会话状态有本质区别：

1. 上下文（Context）：是请求级别的临时状态，生命周期仅限于单个HTTP请求，适合传递认证信息、请求ID、超时设置等
2. 会话（Session）：是用户级别的持久状态，跨多个请求存在，通常存储在cookie或服务端存储中

// 请求级状态（上下文）
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 这些是请求级状态
    requestID := r.Context().Value("request_id").(string)
    startTime := r.Context().Value("start_time").(time.Time)
    
    // 这些应该是会话状态
    // 不应该通过上下文传递
}

// 正确的会话使用
func handleUserRequest(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "user_session")
    userPrefs := session.Values["preferences"]  // 跨请求持久化
    
    ctx := r.Context()
    ctx = context.WithValue(ctx, "request_specific", "temp_value")  // 仅本次请求有效
}

在实际项目中，通常会结合使用会话和上下文：会话用于持久化用户状态，上下文用于传递请求处理过程中的临时状态。