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

// 创建缓存实例
// 第一个参数：默认过期时间（24小时）
// 第二个参数：清理间隔（5分钟）- 多久清理一次过期项
c := cache.New(24*time.Hour, 5*time.Minute)

2. 设置缓存值

// 使用默认过期时间设置
c.Set("key1", "value1", cache.DefaultExpiration)

// 使用自定义过期时间设置（30分钟）
c.Set("key2", "value2", 30*time.Minute)

// 设置永久不过期（使用 cache.NoExpiration）
c.Set("key3", "value3", cache.NoExpiration)

3. 获取缓存值

// 获取缓存值，如果存在返回值和true，否则返回nil和false
value, found := c.Get("key1")
if found {
    // 类型断言获取具体类型
    str := value.(string)
    fmt.Println("缓存值:", str)
}

4. 删除缓存项

// 删除指定key的缓存
c.Delete("key1")

// 清空所有缓存
c.Flush()

5. 其他常用方法

// 增加过期时间（如果key存在）
c.Increment("counter", 1)

// 减少值（如果key存在）
c.Decrement("counter", 1)

// 获取缓存项数量
itemCount := c.ItemCount()

// 获取所有键
keys := c.Keys()

实际项目应用

下面通过一个实际项目案例来展示如何在真实场景中使用 go-cache。

项目场景

在开发 Bing 每日壁纸 API 服务时，我们使用缓存来减少对 Bing API 的重复请求。由于 Bing 每日壁纸每天只更新一次，我们可以将结果缓存 24 小时。

完整代码实现

// bingCache Bing 数据缓存，缓存一天，每5分钟清理一次过期项
var bingCache = cache.New(24*time.Hour, 5*time.Minute)

const cacheKey = "bing_image_url"

// getBingData 获取 Bing API 数据，并返回 MediaContents[0].ImageContent.Image.Url
func getBingData(c *gin.Context) {
	// 先检查缓存
	if cachedURL, found := bingCache.Get(cacheKey); found {
		// 缓存有效，直接使用缓存的值
		c.Redirect(http.StatusFound, cachedURL.(string))
		return
	}

	// 缓存无效或不存在，从 API 获取新数据
	fullURL, err := fetchBingData()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": err.Error(),
		})
		return
	}

	// 更新缓存（使用默认过期时间 24 小时）
	bingCache.Set(cacheKey, fullURL, cache.DefaultExpiration)

	// 直接重定向到图片 URL
	c.Redirect(http.StatusFound, fullURL)
}

代码解析

缓存初始化（第18-19行）
- 创建缓存实例，默认过期时间为 24 小时
- 每 5 分钟自动清理一次过期项
缓存查询（第48-52行）
- 在处理请求时，首先检查缓存中是否存在数据
- 如果缓存命中，直接使用缓存的值，避免调用外部API
缓存更新（第64行）
- 当缓存未命中时，从API获取新数据
- 将获取的数据存入缓存，供后续请求使用

性能优化效果

使用缓存后，该API服务的性能显著提升：

首次请求：需要调用 Bing API（约 200-500ms）
后续请求：直接从缓存读取（< 1ms）
缓存命中率：在24小时内接近 100%（除首次请求外）
服务器负载：减少 99% 以上的外部API调用

缓存策略

在实际应用中，选择合适的缓存策略非常重要：

1. 过期时间设置

短期缓存：频繁变化的数据，如用户会话（30分钟-2小时）
中期缓存：相对稳定的数据，如配置信息（1-24小时）
长期缓存：很少变化的数据，如静态资源URL（24小时以上）

2. 缓存键设计

良好的缓存键设计有助于缓存管理和调试：

// 推荐：使用有意义的键名，包含业务含义
const cacheKey = "bing_image_url"

// 推荐：包含版本号
const cacheKey = "user_profile_v1_123"

// 推荐：包含时间维度
const cacheKey = fmt.Sprintf("daily_report_%s", date)

// 不推荐：过于简单或容易冲突
const cacheKey = "data"

3. 缓存失效策略

// 主动删除：当数据更新时，主动删除相关缓存
func updateUserProfile(userID int, profile UserProfile) error {
    // 更新数据库
    err := db.UpdateProfile(userID, profile)
    if err != nil {
        return err
    }
    
    // 删除相关缓存
    cacheKey := fmt.Sprintf("user_profile_%d", userID)
    c.Delete(cacheKey)
    
    return nil
}

4. 缓存预热

在应用启动时，预加载常用数据到缓存：

func warmupCache() {
    // 预加载常用数据
    popularUsers := getPopularUsers()
    for _, user := range popularUsers {
        cacheKey := fmt.Sprintf("user_profile_%d", user.ID)
        c.Set(cacheKey, user, 1*time.Hour)
    }
}

高级用法

1. 批量操作

// 批量设置
items := map[string]interface{}{
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
}
for k, v := range items {
    c.Set(k, v, cache.DefaultExpiration)
}

// 批量获取（需要手动实现）
func batchGet(c *cache.Cache, keys []string) map[string]interface{} {
    result := make(map[string]interface{})
    for _, key := range keys {
        if value, found := c.Get(key); found {
            result[key] = value
        }
    }
    return result
}

2. 缓存统计

// 获取缓存统计信息
itemCount := c.ItemCount()
fmt.Printf("当前缓存项数量: %d\n", itemCount)

// 获取所有键
keys := c.Keys()
fmt.Printf("缓存键列表: %v\n", keys)

3. 自定义过期策略

// 根据数据类型设置不同的过期时间
func setWithStrategy(key string, value interface{}, dataType string) {
    var expiration time.Duration
    switch dataType {
    case "user":
        expiration = 30 * time.Minute
    case "config":
        expiration = 1 * time.Hour
    case "static":
        expiration = 24 * time.Hour
    default:
        expiration = cache.DefaultExpiration
    }
    c.Set(key, value, expiration)
}

注意事项和最佳实践

1. 类型安全

缓存返回的是 interface{} 类型，需要进行类型断言：

// 正确的类型断言方式
if value, found := c.Get("key"); found {
    if str, ok := value.(string); ok {
        // 使用 str
    } else {
        // 类型不匹配的处理
    }
}

2. 内存管理

监控内存使用：定期检查缓存大小，避免内存溢出
设置合理的过期时间：及时清理不再需要的数据
定期清理：对于不再使用的缓存项，主动删除

3. 并发安全

go-cache 是线程安全的，可以在多个 goroutine 中并发使用，但需要注意：

// 多个 goroutine 同时读写是安全的
go func() {
    c.Set("key1", "value1", cache.DefaultExpiration)
}()

go func() {
    value, _ := c.Get("key1")
    fmt.Println(value)
}()

4. 错误处理

func getFromCacheWithFallback(key string, fallback func() (interface{}, error)) (interface{}, error) {
    // 尝试从缓存获取
    if value, found := c.Get(key); found {
        return value, nil
    }
    
    // 缓存未命中，执行回调函数获取数据
    value, err := fallback()
    if err != nil {
        return nil, err
    }
    
    // 存入缓存
    c.Set(key, value, cache.DefaultExpiration)
    return value, nil
}