Golang如何读取Session Storage数据

在Go标准库中，没有直接读取浏览器Session Storage的API，因为Session Storage是浏览器端的存储机制。不过，你可以通过以下方式处理：

1. 通过HTTP请求传递Session Storage数据

客户端可以将Session Storage数据通过请求头或请求体发送到服务器：

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

// 客户端发送的数据结构
type SessionData struct {
    UserID    string `json:"user_id"`
    Theme     string `json:"theme"`
    LastVisit string `json:"last_visit"`
}

func handleSessionData(w http.ResponseWriter, r *http.Request) {
    // 从请求头读取
    sessionID := r.Header.Get("X-Session-ID")
    if sessionID != "" {
        fmt.Printf("Session ID from header: %s\n", sessionID)
    }

    // 从JSON请求体读取
    if r.Method == "POST" {
        var sessionData SessionData
        if err := json.NewDecoder(r.Body).Decode(&sessionData); err != nil {
            http.Error(w, "Invalid session data", http.StatusBadRequest)
            return
        }
        
        fmt.Printf("User ID: %s, Theme: %s\n", 
            sessionData.UserID, sessionData.Theme)
        
        w.WriteHeader(http.StatusOK)
        json.NewEncoder(w).Encode(map[string]string{
            "status": "session data received",
        })
    }
}

func main() {
    http.HandleFunc("/session", handleSessionData)
    http.ListenAndServe(":8080", nil)
}

2. 使用URL查询参数

func handleQuerySession(w http.ResponseWriter, r *http.Request) {
    // 从查询参数读取
    token := r.URL.Query().Get("session_token")
    theme := r.URL.Query().Get("theme")
    
    if token != "" {
        fmt.Printf("Session token: %s, Theme: %s\n", token, theme)
    }
    
    w.Write([]byte("Session data processed"))
}

3. 完整的示例：处理客户端发送的Session数据

package main

import (
    "log"
    "net/http"
    "time"
)

// 服务器端Session存储
var serverSessions = make(map[string]map[string]string)

func main() {
    http.HandleFunc("/api/sync-session", syncSessionHandler)
    http.HandleFunc("/api/get-session", getSessionHandler)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func syncSessionHandler(w http.ResponseWriter, r *http.Request) {
    // 解析客户端发送的Session数据
    r.ParseForm()
    
    sessionID := r.FormValue("session_id")
    key := r.FormValue("key")
    value := r.FormValue("value")
    
    if sessionID == "" || key == "" {
        http.Error(w, "Missing parameters", http.StatusBadRequest)
        return
    }
    
    // 在服务器端存储Session数据
    if _, exists := serverSessions[sessionID]; !exists {
        serverSessions[sessionID] = make(map[string]string)
    }
    
    serverSessions[sessionID][key] = value
    serverSessions[sessionID]["last_sync"] = time.Now().Format(time.RFC3339)
    
    w.Header().Set("Content-Type", "application/json")
    w.Write([]byte(`{"status": "synced"}`))
}

func getSessionHandler(w http.ResponseWriter, r *http.Request) {
    sessionID := r.URL.Query().Get("session_id")
    key := r.URL.Query().Get("key")
    
    if sessionData, exists := serverSessions[sessionID]; exists {
        if key != "" {
            if value, ok := sessionData[key]; ok {
                w.Write([]byte(value))
                return
            }
        }
    }
    
    w.Write([]byte(""))
}

4. 客户端JavaScript示例

// 客户端发送Session Storage数据到Go服务器
async function syncSessionToServer() {
    const sessionData = {
        user_id: sessionStorage.getItem('user_id'),
        theme: sessionStorage.getItem('theme'),
        token: sessionStorage.getItem('auth_token')
    };
    
    const response = await fetch('/api/sync-session', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-Session-ID': sessionStorage.getItem('session_id')
        },
        body: JSON.stringify(sessionData)
    });
    
    return response.json();
}

关键点说明：

1. Session Storage是浏览器端存储，Go服务器无法直接访问

2. 数据必须由客户端主动发送到服务器

3. 常用传输方式：

   • HTTP请求头（X-Session-*）
   • JSON请求体
   • URL查询参数
   • Form数据

4. 服务器端Session管理：

// 简单的内存Session存储
type SessionManager struct {
    sessions map[string]*Session
    mu       sync.RWMutex
}

type Session struct {
    ID        string
    Data      map[string]interface{}
    CreatedAt time.Time
    ExpiresAt time.Time
}

func (sm *SessionManager) GetSession(sessionID string) (*Session, bool) {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    
    session, exists := sm.sessions[sessionID]
    if !exists || time.Now().After(session.ExpiresAt) {
        return nil, false
    }
    return session, true
}

Go服务器只能处理客户端主动发送的Session Storage数据，无法直接读取浏览器存储。实际应用中，通常会让客户端在需要时将相关数据包含在请求中发送到服务器。