go 框架中的缓存模式包括：全局变量：简单易实现，但维护麻烦，无法控制生命周期。本地缓存：线程安全，每个 goroutine 独立，但每个 goroutine 都需创建和管理自己的缓存。基于上下文的缓存：消除缓存泄漏风险，按需加载缓存，但实现略复杂。

Go 框架中缓存设计模式

简介

缓存是一种存储临时数据的技术，可提高应用程序的性能和响应能力。在 Go 框架中，有几种常见的缓存设计模式，包括：

立即学习“go语言免费学习笔记（深入）”；

全局变量

优点：

• 简单直接
• 易于实现

缺点：

• 维护多个全局变量可能很麻烦
• 无法控制缓存的生命周期

import (
  "sync"
  "time"
)

// 全局缓存，所有 goroutine 共享
var dataCache sync.Map

func SetData(key string, value interface{}) {
  dataCache.Store(key, value)
}

func GetData(key string) (interface{}, bool) {
  return dataCache.Load(key)
}

本地缓存

优点：

• 线程安全
• 缓存独立于进程

缺点：

• 每个 goroutine 都需要创建和管理自己的缓存

import (
  "context"
  "sync"
)

// 本地缓存，每个 goroutine 一个
func NewLocalCache() *localCache {
  return &localCache{
    data: make(map[string]interface{}),
  }
}

type localCache struct {
  data map[string]interface{}
  sync.Mutex
}

func (c *localCache) SetData(key string, value interface{}) {
  c.Lock()
  defer c.Unlock()
  c.data[key] = value
}

func (c *localCache) GetData(key string) (interface{}, bool) {
  c.Lock()
  defer c.Unlock()
  val, ok := c.data[key]
  return val, ok
}

基于上下文的缓存

优点：

• 消除缓存泄漏风险
• 允许按需加载缓存

缺点：

• 实现稍微复杂

import (
  "context"
  "sync"
)

// 基于上下文的缓存，与 request 绑定
type ContextCache struct {
  data sync.Map
}

func GetContextCache(ctx context.Context) (*ContextCache, bool) {
  cache, ok := ctx.Value("cache").(*ContextCache)
  return cache, ok
}

func (c *ContextCache) SetData(key string, value interface{}) {
  c.data.Store(key, value)
}

func (c *ContextCache) GetData(key string) (interface{}, bool) {
  return c.data.Load(key)
}

实战案例

使用全局缓存缓存用户会话信息：

import (
  "context"
  "sync"
)

var userSessions sync.Map

func SetUserSession(ctx context.Context, userId string, session interface{}) {
  userSessions.Store(userId, session)
}

func GetUserSession(ctx context.Context, userId string) (interface{}, bool) {
  return userSessions.Load(userId)
}

选择合适的模式

选择合适的缓存设计模式取决于应用程序的具体要求。对于简单的应用程序，全局变量可能就足够了。对于需要线程安全或缓存隔离的高性能应用程序，本地缓存或基于上下文的缓存可能是更好的选择。