Golang多驱动缓存组件插件库CacheGo使用指南

CacheGo是一个支持多驱动(Redis、Memcached、内存等)的Golang缓存组件库，提供了统一的接口来操作不同的缓存后端。

安装CacheGo

go get -u github.com/faabiosr/cachego

基本使用

1. 创建缓存实例

package main

import (
	"fmt"
	"time"
	
	"github.com/faabiosr/cachego"
	"github.com/faabiosr/cachego/file"
	"github.com/faabiosr/cachego/memcached"
	"github.com/faabiosr/cachego/memory"
	"github.com/faabiosr/cachego/redis"
)

func main() {
	// 内存缓存
	memCache := memory.New()
	
	// Redis缓存
	redisCache := redis.New("localhost:6379", "", 0)
	
	// Memcached缓存
	memcachedCache := memcached.New("localhost:11211")
	
	// 文件缓存
	fileCache := file.New("/tmp/cache")
	
	// 使用统一的接口操作
	useCache(memCache)
	useCache(redisCache)
	useCache(memcachedCache)
	useCache(fileCache)
}

func useCache(cache cachego.Cache) {
	// 设置缓存
	cache.Save("key", "value", 10*time.Minute)
	
	// 获取缓存
	value := cache.Fetch("key")
	fmt.Println(value)
	
	// 删除缓存
	cache.Delete("key")
	
	// 检查是否存在
	exists := cache.Contains("key")
	fmt.Println("Exists:", exists)
}

2. 支持的驱动

CacheGo支持以下驱动：

• 内存缓存：memory.New()
• Redis缓存：redis.New(addr, password string, db int)
• Memcached缓存：memcached.New(addr string)
• 文件缓存：file.New(path string)

3. 高级功能

批量操作

// 批量保存
items := map[string]cachego.Item{
	"key1": {Value: "value1", TTL: 5 * time.Minute},
	"key2": {Value: "value2", TTL: 10 * time.Minute},
}
cache.SaveMulti(items)

// 批量获取
values := cache.FetchMulti("key1", "key2")
fmt.Println(values)

原子操作

// 原子递增
newValue, err := cache.Increment("counter", 1)
if err != nil {
	fmt.Println("Increment error:", err)
}

// 原子递减
newValue, err = cache.Decrement("counter", 1)
if err != nil {
	fmt.Println("Decrement error:", err)
}

清空缓存

err := cache.Flush()
if err != nil {
	fmt.Println("Flush error:", err)
}

4. 自定义驱动

CacheGo支持自定义驱动，只需实现cachego.Cache接口：

type MyCache struct{}

func (c *MyCache) Save(key string, value interface{}, ttl time.Duration) error {
	// 实现保存逻辑
	return nil
}

func (c *MyCache) Fetch(key string) string {
	// 实现获取逻辑
	return ""
}

// 实现其他必要方法...

func main() {
	customCache := &MyCache{}
	useCache(customCache)
}

最佳实践

1. 选择合适的驱动：

   • 单机应用：内存缓存
   • 分布式系统：Redis或Memcached
   • 需要持久化：文件缓存或Redis

2. 合理设置TTL：

   // 根据数据特性设置合适的过期时间
   cache.Save("user:123", userData, 24*time.Hour)  // 用户数据缓存24小时
   cache.Save("temp:data", tempData, 5*time.Minute) // 临时数据缓存5分钟
   

3. 错误处理：

   if err := cache.Save("key", "value", 10*time.Minute); err != nil {
       log.Printf("Failed to save cache: %v", err)
       // 降级处理或重试
   }
   

4. 缓存穿透防护：

   value := cache.Fetch("key")
   if value == "" {
       // 从数据库获取
       dbValue := getFromDB("key")
       if dbValue != "" {
           cache.Save("key", dbValue, 5*time.Minute)
       } else {
           // 防止缓存穿透，设置空值短时间缓存
           cache.Save("key", "NULL", 1*time.Minute)
       }
   }
   

CacheGo通过统一的接口简化了多缓存后端的操作，使得在不同环境切换缓存实现变得非常简单，是Golang项目中处理缓存需求的优秀选择。