在 Golang 中，常见的缓存框架主要是用于加速应用程序的性能，通过减少频繁的数据库查询或复杂计算的需求。以下是一些 Golang 常见的缓存框架：
Life is like a journey
GoCache 是一个强大的内存缓存库，提供了类似于 Memcached 的缓存功能，支持过期时间和自动清除失效缓存。go get github.com/patrickmn/go-cache
package main
import (
"fmt"
"github.com/patrickmn/go-cache"
"time"
)
func main() {
c := cache.New(5*time.Minute, 10*time.Minute)
// 设置缓存
c.Set("foo", "bar", cache.DefaultExpiration)
// 获取缓存
val, found := c.Get("foo")
if found {
fmt.Println("Found:", val)
} else {
fmt.Println("Not Found")
}
}
BigCache 是一个高效的内存缓存库，设计用于解决大规模、高并发的缓存场景。它提供了高效的内存管理，特别适用于大数据量缓存。go get github.com/allegro/bigcache
package main
import (
"fmt"
"github.com/allegro/bigcache/v3"
"time"
)
func main() {
cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))
// 设置缓存
cache.Set("foo", []byte("bar"))
// 获取缓存
val, err := cache.Get("foo")
if err == nil {
fmt.Println("Found:", string(val))
} else {
fmt.Println("Not Found")
}
}
Ristretto 是一个非常高效的缓存库，旨在提供更高性能和更低延迟。它使用了一种高效的缓存替换算法。go get github.com/dgraph-io/ristretto
package main
import (
"fmt"
"github.com/dgraph-io/ristretto"
"log"
)
func main() {
cache, err := ristretto.NewCache(&ristretto.Config{
NumCounters: 1e7, // Number of keys to track frequency of (10M).
MaxCost: 1 << 30, // Maximum cost of cache (1GB).
BufferItems: 64,
})
if err != nil {
log.Fatal(err)
}
// 设置缓存
cache.Set("foo", "bar", 1)
// 获取缓存
val, found := cache.Get("foo")
if found {
fmt.Println("Found:", val)
} else {
fmt.Println("Not Found")
}
}
Groupcache 是一个分布式缓存库，类似于 Memcached，但具有更强的分布式特性。它特别适用于大规模分布式缓存应用。go get github.com/golang/groupcache
package main
import (
"fmt"
"github.com/golang/groupcache"
)
var peers = groupcache.NewHTTPPool("localhost:8080")
func main() {
cache := groupcache.NewGroup("example", 64<<20, groupcache.GetterFunc(func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
// 回退获取数据的逻辑，例如从数据库中加载数据
dest.SetString("This is the data for " + key)
return nil
}))
// 获取缓存
var data string
err := cache.Get(nil, "key1", groupcache.StringSink(&data))
if err != nil {
fmt.Println("Error:", err)
}
fmt.Println("Cached Data:", data)
}
Go-Redis 是一个高性能的 Redis 客户端，可以将 Redis 作为 Golang 中的缓存层。通过使用 Redis，开发者可以利用 Redis 强大的分布式缓存、持久化、队列等功能。go get github.com/go-redis/redis/v8
package main
import (
"fmt"
"github.com/go-redis/redis/v8"
"context"
)
var rdb *redis.Client
func init() {
rdb = redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
}
func main() {
ctx := context.Background()
// 设置缓存
err := rdb.Set(ctx, "foo", "bar", 0).Err()
if err != nil {
panic(err)
}
// 获取缓存
val, err := rdb.Get(ctx, "foo").Result()
if err != nil {
panic(err)
}
fmt.Println("Found:", val)
}
Cache2go 是一个非常简单的 Golang 内存缓存库，支持缓存失效和定时清理。go get github.com/muesli/cache2go
package main
import (
"fmt"
"github.com/muesli/cache2go"
)
func main() {
cache := cache2go.Cache("example")
// 设置缓存
cache.Add("foo", 0, "bar")
// 获取缓存
item, err := cache.Value("foo")
if err == nil {
fmt.Println("Found:", item.Data)
} else {
fmt.Println("Not Found")
}
}
这些缓存框架各有特点，选择合适的框架取决于应用需求：