398 lines
9.6 KiB
Go
398 lines
9.6 KiB
Go
package session
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/google/uuid"
|
||
)
|
||
|
||
// SessionManager Session管理器，负责Session的创建、获取和销毁
|
||
type SessionManager struct {
|
||
sessions map[string]*Session // 存储所有活跃的Session，key为SessionID
|
||
mutex sync.RWMutex // 读写锁，保证并发安全
|
||
maxAge time.Duration // Session最大存活时间
|
||
}
|
||
|
||
// Session 单个Session对象，用于存储用户数据
|
||
type Session struct {
|
||
ID string // Session唯一标识符
|
||
Data map[string]interface{} // 存储的数据，键值对形式
|
||
CreateTime time.Time // 创建时间
|
||
LastAccess time.Time // 最后访问时间
|
||
mutex sync.RWMutex // 读写锁，保证并发安全
|
||
}
|
||
|
||
var (
|
||
// defaultManager 默认的Session管理器实例
|
||
defaultManager *SessionManager
|
||
// once 确保只初始化一次
|
||
once sync.Once
|
||
)
|
||
|
||
// init 包初始化时自动创建默认管理器
|
||
func init() {
|
||
InitDefaultManager(30 * time.Minute) // 默认30分钟过期
|
||
}
|
||
|
||
// InitDefaultManager 初始化默认Session管理器
|
||
// 参数 duration: Session的最大存活时间
|
||
func InitDefaultManager(duration time.Duration) {
|
||
once.Do(func() {
|
||
defaultManager = NewSessionManager(duration)
|
||
})
|
||
}
|
||
|
||
// NewSessionManager 创建一个新的Session管理器
|
||
// 参数 duration: Session的最大存活时间
|
||
// 返回值: Session管理器指针
|
||
func NewSessionManager(duration time.Duration) *SessionManager {
|
||
sm := &SessionManager{
|
||
sessions: make(map[string]*Session),
|
||
maxAge: duration,
|
||
}
|
||
|
||
// 启动定时清理任务，每5分钟清理一次过期的Session
|
||
go sm.startCleanupTicker(5 * time.Minute)
|
||
|
||
return sm
|
||
}
|
||
|
||
// startCleanupTicker 启动定时清理过期Session的任务
|
||
// 参数 interval: 清理间隔时间
|
||
func (sm *SessionManager) startCleanupTicker(interval time.Duration) {
|
||
ticker := time.NewTicker(interval)
|
||
defer ticker.Stop()
|
||
|
||
for range ticker.C {
|
||
sm.CleanupExpiredSessions()
|
||
}
|
||
}
|
||
|
||
// CreateSession 创建新的Session并返回Session ID
|
||
// 参数 c: Gin上下文对象
|
||
// 返回值: Session ID字符串
|
||
func (sm *SessionManager) CreateSession(c *gin.Context) string {
|
||
sessionID := uuid.New().String()
|
||
|
||
session := &Session{
|
||
ID: sessionID,
|
||
Data: make(map[string]interface{}),
|
||
CreateTime: time.Now(),
|
||
LastAccess: time.Now(),
|
||
}
|
||
|
||
sm.mutex.Lock()
|
||
sm.sessions[sessionID] = session
|
||
sm.mutex.Unlock()
|
||
|
||
// 设置Cookie，保存Session ID
|
||
c.SetCookie(
|
||
"session_id", // Cookie名称
|
||
sessionID, // Cookie值
|
||
int(sm.maxAge.Seconds()), // 过期时间（秒）
|
||
"/", // 路径
|
||
"", // 域名（空表示当前域名）
|
||
false, // 是否仅HTTPS
|
||
true, // 是否HttpOnly（防止XSS攻击）
|
||
)
|
||
|
||
return sessionID
|
||
}
|
||
|
||
// GetSession 根据Gin上下文获取Session对象
|
||
// 参数 c: Gin上下文对象
|
||
// 返回值: Session对象指针，如果不存在则返回nil
|
||
func (sm *SessionManager) GetSession(c *gin.Context) *Session {
|
||
sessionID, err := c.Cookie("session_id")
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
|
||
sm.mutex.RLock()
|
||
session, exists := sm.sessions[sessionID]
|
||
sm.mutex.RUnlock()
|
||
|
||
if !exists {
|
||
return nil
|
||
}
|
||
|
||
// 检查Session是否过期
|
||
if time.Since(session.LastAccess) > sm.maxAge {
|
||
sm.DestroySession(sessionID)
|
||
return nil
|
||
}
|
||
|
||
// 更新最后访问时间
|
||
session.mutex.Lock()
|
||
session.LastAccess = time.Now()
|
||
session.mutex.Unlock()
|
||
|
||
return session
|
||
}
|
||
|
||
// GetSessionByID 根据Session ID获取Session对象
|
||
// 参数 sessionID: Session的唯一标识符
|
||
// 返回值: Session对象指针，如果不存在则返回nil
|
||
func (sm *SessionManager) GetSessionByID(sessionID string) *Session {
|
||
sm.mutex.RLock()
|
||
session, exists := sm.sessions[sessionID]
|
||
sm.mutex.RUnlock()
|
||
|
||
if !exists {
|
||
return nil
|
||
}
|
||
|
||
// 检查Session是否过期
|
||
if time.Since(session.LastAccess) > sm.maxAge {
|
||
sm.DestroySession(sessionID)
|
||
return nil
|
||
}
|
||
|
||
// 更新最后访问时间
|
||
session.mutex.Lock()
|
||
session.LastAccess = time.Now()
|
||
session.mutex.Unlock()
|
||
|
||
return session
|
||
}
|
||
|
||
// DestroySession 销毁指定的Session
|
||
// 参数 sessionID: Session的唯一标识符
|
||
func (sm *SessionManager) DestroySession(sessionID string) {
|
||
sm.mutex.Lock()
|
||
delete(sm.sessions, sessionID)
|
||
sm.mutex.Unlock()
|
||
}
|
||
|
||
// DestroySessionByContext 根据Gin上下文销毁Session
|
||
// 参数 c: Gin上下文对象
|
||
func (sm *SessionManager) DestroySessionByContext(c *gin.Context) {
|
||
sessionID, err := c.Cookie("session_id")
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
sm.DestroySession(sessionID)
|
||
|
||
// 清除Cookie
|
||
c.SetCookie(
|
||
"session_id",
|
||
"",
|
||
-1, // 立即过期
|
||
"/",
|
||
"",
|
||
false,
|
||
true,
|
||
)
|
||
}
|
||
|
||
// CleanupExpiredSessions 清理所有过期的Session
|
||
func (sm *SessionManager) CleanupExpiredSessions() {
|
||
now := time.Now()
|
||
expiredIDs := make([]string, 0)
|
||
|
||
sm.mutex.RLock()
|
||
for id, session := range sm.sessions {
|
||
session.mutex.RLock()
|
||
if now.Sub(session.LastAccess) > sm.maxAge {
|
||
expiredIDs = append(expiredIDs, id)
|
||
}
|
||
session.mutex.RUnlock()
|
||
}
|
||
sm.mutex.RUnlock()
|
||
|
||
// 删除过期的Session
|
||
sm.mutex.Lock()
|
||
for _, id := range expiredIDs {
|
||
delete(sm.sessions, id)
|
||
}
|
||
sm.mutex.Unlock()
|
||
}
|
||
|
||
// GetSessionCount 获取当前活跃的Session数量
|
||
// 返回值: Session数量
|
||
func (sm *SessionManager) GetSessionCount() int {
|
||
sm.mutex.RLock()
|
||
defer sm.mutex.RUnlock()
|
||
return len(sm.sessions)
|
||
}
|
||
|
||
// Set 在Session中设置键值对
|
||
// 参数 key: 键名
|
||
// 参数 value: 值
|
||
func (s *Session) Set(key string, value interface{}) {
|
||
s.mutex.Lock()
|
||
defer s.mutex.Unlock()
|
||
s.Data[key] = value
|
||
}
|
||
|
||
// Get 从Session中获取值
|
||
// 参数 key: 键名
|
||
// 返回值: 对应的值，如果不存在则返回nil
|
||
func (s *Session) Get(key string) interface{} {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
return s.Data[key]
|
||
}
|
||
|
||
// GetString 从Session中获取字符串类型的值
|
||
// 参数 key: 键名
|
||
// 返回值: 字符串值，如果不存在或类型不匹配则返回空字符串
|
||
func (s *Session) GetString(key string) string {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
if val, ok := s.Data[key]; ok {
|
||
if str, ok := val.(string); ok {
|
||
return str
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// GetInt 从Session中获取整数类型的值
|
||
// 参数 key: 键名
|
||
// 返回值: 整数值，如果不存在或类型不匹配则返回0
|
||
func (s *Session) GetInt(key string) int {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
if val, ok := s.Data[key]; ok {
|
||
switch v := val.(type) {
|
||
case int:
|
||
return v
|
||
case float64: // JSON解码时数字会变成float64
|
||
return int(v)
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// GetFloat64 从Session中获取浮点数类型的值
|
||
// 参数 key: 键名
|
||
// 返回值: 浮点数值，如果不存在或类型不匹配则返回0
|
||
func (s *Session) GetFloat64(key string) float64 {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
if val, ok := s.Data[key]; ok {
|
||
switch v := val.(type) {
|
||
case float64:
|
||
return v
|
||
case int:
|
||
return float64(v)
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// GetBool 从Session中获取布尔类型的值
|
||
// 参数 key: 键名
|
||
// 返回值: 布尔值，如果不存在或类型不匹配则返回false
|
||
func (s *Session) GetBool(key string) bool {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
if val, ok := s.Data[key]; ok {
|
||
if b, ok := val.(bool); ok {
|
||
return b
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// Delete 从Session中删除指定的键
|
||
// 参数 key: 要删除的键名
|
||
func (s *Session) Delete(key string) {
|
||
s.mutex.Lock()
|
||
defer s.mutex.Unlock()
|
||
delete(s.Data, key)
|
||
}
|
||
|
||
// Clear 清空Session中的所有数据
|
||
func (s *Session) Clear() {
|
||
s.mutex.Lock()
|
||
defer s.mutex.Unlock()
|
||
s.Data = make(map[string]interface{})
|
||
}
|
||
|
||
// Has 检查Session中是否存在指定的键
|
||
// 参数 key: 键名
|
||
// 返回值: 如果存在返回true，否则返回false
|
||
func (s *Session) Has(key string) bool {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
_, exists := s.Data[key]
|
||
return exists
|
||
}
|
||
|
||
// GetAll 获取Session中的所有数据
|
||
// 返回值: 包含所有数据的map副本
|
||
func (s *Session) GetAll() map[string]interface{} {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
|
||
// 返回副本，避免外部修改
|
||
result := make(map[string]interface{}, len(s.Data))
|
||
for k, v := range s.Data {
|
||
result[k] = v
|
||
}
|
||
return result
|
||
}
|
||
|
||
// ToJSON 将Session数据转换为JSON字符串
|
||
// 返回值: JSON字符串，如果转换失败则返回错误
|
||
func (s *Session) ToJSON() (string, error) {
|
||
s.mutex.RLock()
|
||
defer s.mutex.RUnlock()
|
||
|
||
data, err := json.Marshal(s.Data)
|
||
if err != nil {
|
||
return "", fmt.Errorf("序列化Session数据失败: %w", err)
|
||
}
|
||
|
||
return string(data), nil
|
||
}
|
||
|
||
// FromJSON 从JSON字符串恢复Session数据
|
||
// 参数 jsonStr: JSON字符串
|
||
// 返回值: 如果解析失败则返回错误
|
||
func (s *Session) FromJSON(jsonStr string) error {
|
||
s.mutex.Lock()
|
||
defer s.mutex.Unlock()
|
||
|
||
var data map[string]interface{}
|
||
if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
|
||
return fmt.Errorf("反序列化Session数据失败: %w", err)
|
||
}
|
||
|
||
s.Data = data
|
||
return nil
|
||
}
|
||
|
||
// GetDefaultManager 获取默认的Session管理器
|
||
// 返回值: 默认Session管理器指针
|
||
func GetDefaultManager() *SessionManager {
|
||
return defaultManager
|
||
}
|
||
|
||
// CreateSession 使用默认管理器创建Session
|
||
// 参数 c: Gin上下文对象
|
||
// 返回值: Session ID字符串
|
||
func CreateSession(c *gin.Context) string {
|
||
return defaultManager.CreateSession(c)
|
||
}
|
||
|
||
// GetSession 使用默认管理器获取Session
|
||
// 参数 c: Gin上下文对象
|
||
// 返回值: Session对象指针
|
||
func GetSession(c *gin.Context) *Session {
|
||
return defaultManager.GetSession(c)
|
||
}
|
||
|
||
// DestroySession 使用默认管理器销毁Session
|
||
// 参数 c: Gin上下文对象
|
||
func DestroySession(c *gin.Context) {
|
||
defaultManager.DestroySessionByContext(c)
|
||
}
|