GoCache - Golang多存储缓存库

GoCache 是一个支持多级缓存的 Golang 库，可以链式组合内存、Redis、Memcached 等多种存储后端。下面我将详细介绍其使用方法和示例代码。

主要特性

1. 支持多级缓存链式组合
2. 内置内存、Redis、Memcached 等存储后端
3. 简单的 API 设计
4. 支持缓存过期时间设置
5. 支持缓存穿透保护

安装

go get github.com/eko/gocache/v2

基本使用示例

1. 仅使用内存缓存

package main

import (
	"fmt"
	"time"
	
	"github.com/eko/gocache/v2/cache"
	"github.com/eko/gocache/v2/store"
)

func main() {
	// 初始化内存存储
	memoryStore := store.NewMemoryStore()
	
	// 创建缓存管理器
	cacheManager := cache.New(memoryStore)
	
	// 设置缓存
	err := cacheManager.Set("my-key", []byte("my-value"), &store.Options{
		Expiration: 5 * time.Minute,
	})
	if err != nil {
		panic(err)
	}
	
	// 获取缓存
	value, err := cacheManager.Get("my-key")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(string(value)) // 输出: my-value
	
	// 删除缓存
	err = cacheManager.Delete("my-key")
	if err != nil {
		panic(err)
	}
}

2. 链式缓存（内存 + Redis）

package main

import (
	"fmt"
	"time"
	
	"github.com/eko/gocache/v2/cache"
	"github.com/eko/gocache/v2/store"
	redisStore "github.com/eko/gocache/store/redis/v2"
	"github.com/go-redis/redis/v8"
)

func main() {
	// 初始化Redis客户端
	redisClient := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})
	
	// 初始化存储
	memoryStore := store.NewMemoryStore()
	redisStore := redisStore.NewRedis(redisClient)
	
	// 创建链式缓存 - 先查内存，再查Redis
	chainStore := store.NewChain(
		store.NewSet(memoryStore, store.WithExpiration(10*time.Minute)),
		store.NewSet(redisStore, store.WithExpiration(30*time.Minute)),
	)
	
	cacheManager := cache.New(chainStore)
	
	// 设置缓存
	err := cacheManager.Set("user-123", []byte("user data"), nil)
	if err != nil {
		panic(err)
	}
	
	// 获取缓存
	value, err := cacheManager.Get("user-123")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(string(value)) // 输出: user data
}

3. 使用 Memcached

package main

import (
	"fmt"
	"time"
	
	"github.com/eko/gocache/v2/cache"
	"github.com/eko/gocache/v2/store"
	memcacheStore "github.com/eko/gocache/store/memcache/v2"
	"github.com/bradfitz/gomemcache/memcache"
)

func main() {
	// 初始化Memcached客户端
	memcacheClient := memcache.New("localhost:11211")
	
	// 初始化Memcached存储
	memcacheStore := memcacheStore.NewMemcache(memcacheClient)
	
	cacheManager := cache.New(memcacheStore)
	
	// 设置缓存
	err := cacheManager.Set("product-456", []byte("product details"), &store.Options{
		Expiration: 1 * time.Hour,
	})
	if err != nil {
		panic(err)
	}
	
	// 获取缓存
	value, err := cacheManager.Get("product-456")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(string(value)) // 输出: product details
}

4. 复杂链式缓存（内存 + Redis + Memcached）

package main

import (
	"fmt"
	"time"
	
	"github.com/eko/gocache/v2/cache"
	"github.com/eko/gocache/v2/store"
	redisStore "github.com/eko/gocache/store/redis/v2"
	memcacheStore "github.com/eko/gocache/store/memcache/v2"
	"github.com/go-redis/redis/v8"
	"github.com/bradfitz/gomemcache/memcache"
)

func main() {
	// 初始化各种客户端
	redisClient := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
	memcacheClient := memcache.New("localhost:11211")
	
	// 初始化各种存储
	memoryStore := store.NewMemoryStore()
	redisStore := redisStore.NewRedis(redisClient)
	memcacheStore := memcacheStore.NewMemcache(memcacheClient)
	
	// 创建链式缓存 - 内存 -> Redis -> Memcached
	chainStore := store.NewChain(
		store.NewSet(memoryStore, store.WithExpiration(5*time.Minute)),
		store.NewSet(redisStore, store.WithExpiration(30*time.Minute)),
		store.NewSet(memcacheStore, store.WithExpiration(2*time.Hour)),
	)
	
	cacheManager := cache.New(chainStore)
	
	// 设置缓存
	err := cacheManager.Set("order-789", []byte("order information"), nil)
	if err != nil {
		panic(err)
	}
	
	// 获取缓存
	value, err := cacheManager.Get("order-789")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(string(value)) // 输出: order information
	
	// 清除所有缓存
	err = cacheManager.Clear()
	if err != nil {
		panic(err)
	}
}

高级功能

1. 缓存穿透保护

// 在初始化存储时添加选项
memoryStore := store.NewMemoryStore(
	store.WithCost(8), // 设置内存成本
	store.WithMetrics(), // 启用指标
	store.WithPenetrationAware(), // 启用缓存穿透保护
)

2. 自定义序列化

type User struct {
	ID   int
	Name string
}

// 自定义序列化
serialized, err := json.Marshal(User{ID: 1, Name: "John"})
if err != nil {
	panic(err)
}

err = cacheManager.Set("user-1", serialized, nil)
if err != nil {
	panic(err)
}

// 反序列化
value, err := cacheManager.Get("user-1")
if err != nil {
	panic(err)
}

var user User
err = json.Unmarshal(value, &user)
if err != nil {
	panic(err)
}

总结

GoCache 提供了灵活的多级缓存解决方案，可以轻松组合不同的存储后端。通过链式缓存，可以实现高效的缓存策略，例如先查内存、再查Redis、最后查数据库等。其简单的API设计和丰富的功能使其成为Golang项目中缓存管理的优秀选择。

在实际项目中，可以根据业务需求选择合适的缓存组合，并合理设置各级缓存的过期时间，以达到最佳的性能和一致性平衡。