Golang中如何实现类似JavaScript localStorage的内存存储

在Golang中实现类似JavaScript localStorage的内存存储，可以使用以下几种方案：

1. 使用全局变量 + sync.RWMutex（最简单方案）

package main

import (
    "sync"
)

var (
    menuCache map[string]interface{}
    cacheLock sync.RWMutex
)

// 初始化缓存
func init() {
    menuCache = make(map[string]interface{})
}

// 设置缓存
func SetMenu(key string, value interface{}) {
    cacheLock.Lock()
    defer cacheLock.Unlock()
    menuCache[key] = value
}

// 获取缓存
func GetMenu(key string) (interface{}, bool) {
    cacheLock.RLock()
    defer cacheLock.RUnlock()
    val, ok := menuCache[key]
    return val, ok
}

// 使用示例
func main() {
    // 模拟从数据库加载菜单
    menuData := map[string]interface{}{
        "main_menu": []string{"首页", "产品", "关于我们"},
        "user_menu": []string{"个人中心", "设置", "退出"},
    }
    
    SetMenu("menus", menuData)
    
    // 获取菜单
    if cached, ok := GetMenu("menus"); ok {
        fmt.Println("从缓存获取菜单:", cached)
    }
}

2. 使用单例模式 + 结构体封装

package main

import (
    "sync"
    "time"
)

type MenuCache struct {
    data    map[string]CacheItem
    mu      sync.RWMutex
}

type CacheItem struct {
    Value      interface{}
    Expiration int64 // 过期时间戳
}

var (
    instance *MenuCache
    once     sync.Once
)

// 获取缓存实例（单例）
func GetMenuCache() *MenuCache {
    once.Do(func() {
        instance = &MenuCache{
            data: make(map[string]CacheItem),
        }
    })
    return instance
}

// 设置带过期时间的缓存
func (c *MenuCache) Set(key string, value interface{}, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    var expiration int64
    if ttl > 0 {
        expiration = time.Now().Add(ttl).UnixNano()
    }
    
    c.data[key] = CacheItem{
        Value:      value,
        Expiration: expiration,
    }
}

// 获取缓存
func (c *MenuCache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, found := c.data[key]
    if !found {
        return nil, false
    }
    
    // 检查是否过期
    if item.Expiration > 0 && time.Now().UnixNano() > item.Expiration {
        return nil, false
    }
    
    return item.Value, true
}

// 使用示例
func main() {
    cache := GetMenuCache()
    
    // 缓存菜单，设置10分钟过期
    menuData := map[string][]string{
        "admin": {"用户管理", "系统设置", "日志查看"},
    }
    
    cache.Set("admin_menu", menuData, 10*time.Minute)
    
    // 获取菜单
    if val, ok := cache.Get("admin_menu"); ok {
        fmt.Println("获取到菜单:", val)
    }
}

3. 使用第三方缓存库（推荐用于生产环境）

package main

import (
    "github.com/patrickmn/go-cache"
    "time"
)

var menuCache *cache.Cache

func init() {
    // 创建缓存，默认5分钟过期，每10分钟清理一次过期项目
    menuCache = cache.New(5*time.Minute, 10*time.Minute)
}

// 缓存菜单数据
func CacheMenu(key string, menu interface{}) {
    // 缓存30分钟
    menuCache.Set(key, menu, 30*time.Minute)
}

// 获取菜单数据
func GetCachedMenu(key string) (interface{}, bool) {
    return menuCache.Get(key)
}

// 使用示例
func main() {
    // 模拟菜单数据
    menus := []struct {
        Name string
        URL  string
    }{
        {"首页", "/"},
        {"产品", "/products"},
        {"关于", "/about"},
    }
    
    // 缓存菜单
    CacheMenu("main_navigation", menus)
    
    // 获取缓存
    if cached, found := GetCachedMenu("main_navigation"); found {
        fmt.Println("从缓存获取:", cached)
    }
    
    // 获取缓存并延长过期时间
    if cached, found := menuCache.Get("main_navigation"); found {
        menuCache.Set("main_navigation", cached, cache.DefaultExpiration)
    }
}

4. 持久化到文件（类似localStorage的持久化）

package main

import (
    "encoding/json"
    "os"
    "sync"
    "time"
)

type PersistentCache struct {
    filePath string
    data     map[string]CacheEntry
    mu       sync.RWMutex
}

type CacheEntry struct {
    Value      interface{} `json:"value"`
    Expiration int64       `json:"expiration"`
    CreatedAt  int64       `json:"created_at"`
}

func NewPersistentCache(filePath string) *PersistentCache {
    cache := &PersistentCache{
        filePath: filePath,
        data:     make(map[string]CacheEntry),
    }
    cache.loadFromFile()
    return cache
}

// 从文件加载缓存
func (c *PersistentCache) loadFromFile() {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    file, err := os.Open(c.filePath)
    if err != nil {
        return
    }
    defer file.Close()
    
    decoder := json.NewDecoder(file)
    decoder.Decode(&c.data)
}

// 保存到文件
func (c *PersistentCache) saveToFile() {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    file, err := os.Create(c.filePath)
    if err != nil {
        return
    }
    defer file.Close()
    
    encoder := json.NewEncoder(file)
    encoder.Encode(c.data)
}

// 设置缓存并持久化
func (c *PersistentCache) Set(key string, value interface{}, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    var expiration int64
    if ttl > 0 {
        expiration = time.Now().Add(ttl).UnixNano()
    }
    
    c.data[key] = CacheEntry{
        Value:      value,
        Expiration: expiration,
        CreatedAt:  time.Now().UnixNano(),
    }
    
    // 异步保存到文件
    go c.saveToFile()
}

// 使用示例
func main() {
    // 创建持久化缓存
    cache := NewPersistentCache("./menu_cache.json")
    
    // 存储菜单数据
    menuData := map[string]interface{}{
        "sidebar": []string{"仪表盘", "消息", "通知"},
    }
    
    cache.Set("user_menus", menuData, 24*time.Hour)
    
    // 程序重启后，数据仍然存在
}

对于你的菜单缓存需求，建议使用方案2或方案3。如果只需要应用运行期间的内存缓存，方案2足够；如果需要更丰富的缓存功能（自动清理、统计等），使用go-cache库（方案3）是最佳选择。