Golang bcache库使用指南

bcache是一个基于Golang实现的最终一致性分布式内存缓存插件库，它提供了简单易用的API来实现分布式缓存功能。下面我将详细介绍bcache的使用方法。

安装

go get github.com/allegro/bigcache/bcache

基本使用

1. 创建缓存实例

package main

import (
	"fmt"
	"time"
	
	"github.com/allegro/bigcache/bcache"
)

func main() {
	// 创建缓存配置
	config := bcache.Config{
		Shards:             1024,           // 分片数量
		LifeWindow:         10 * time.Minute, // 条目存活时间
		CleanWindow:        5 * time.Minute,  // 清理间隔
		MaxEntriesInWindow: 1000 * 10 * 60,   // 存活窗口内的最大条目数
		MaxEntrySize:       500,              // 单个条目最大大小(字节)
		Verbose:            true,             // 是否打印详细日志
		HardMaxCacheSize:   8192,             // 最大缓存大小(MB)
	}
	
	// 创建缓存实例
	cache, err := bcache.NewBigCache(config)
	if err != nil {
		panic(err)
	}
	
	// 使用缓存...
}

2. 基本操作

// 设置缓存
err := cache.Set("key1", []byte("value1"))
if err != nil {
	fmt.Println("Set error:", err)
}

// 获取缓存
entry, err := cache.Get("key1")
if err != nil {
	fmt.Println("Get error:", err)
} else {
	fmt.Println("Got value:", string(entry))
}

// 删除缓存
err = cache.Delete("key1")
if err != nil {
	fmt.Println("Delete error:", err)
}

// 检查缓存是否存在
err = cache.Append("key1", []byte("_append"))
if err == bcache.ErrEntryNotFound {
	fmt.Println("Key does not exist")
}

3. 分布式特性使用

bcache本身是一个单机内存缓存，要实现分布式缓存，通常需要结合其他组件。以下是使用bcache作为本地缓存层，结合Redis实现分布式缓存的示例：

package main

import (
	"fmt"
	"time"
	
	"github.com/allegro/bigcache/bcache"
	"github.com/go-redis/redis/v8"
)

type DistributedCache struct {
	localCache *bcache.BigCache
	redisClient *redis.Client
}

func NewDistributedCache() (*DistributedCache, error) {
	// 本地缓存配置
	localConfig := bcache.Config{
		Shards:             1024,
		LifeWindow:         5 * time.Minute,
		CleanWindow:        1 * time.Minute,
		MaxEntriesInWindow: 1000 * 10 * 60,
		MaxEntrySize:       500,
		HardMaxCacheSize:   1024,
	}
	
	localCache, err := bcache.NewBigCache(localConfig)
	if err != nil {
		return nil, err
	}
	
	// Redis客户端
	redisClient := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})
	
	return &DistributedCache{
		localCache:  localCache,
		redisClient: redisClient,
	}, nil
}

func (dc *DistributedCache) Get(key string) ([]byte, error) {
	// 先查本地缓存
	value, err := dc.localCache.Get(key)
	if err == nil {
		return value, nil
	}
	
	// 本地没有则查Redis
	cmd := dc.redisClient.Get(context.Background(), key)
	if cmd.Err() == redis.Nil {
		return nil, bcache.ErrEntryNotFound
	} else if cmd.Err() != nil {
		return nil, cmd.Err()
	}
	
	// 将Redis结果写入本地缓存
	value = []byte(cmd.Val())
	_ = dc.localCache.Set(key, value)
	
	return value, nil
}

func (dc *DistributedCache) Set(key string, value []byte) error {
	// 先设置Redis
	err := dc.redisClient.Set(context.Background(), key, value, 0).Err()
	if err != nil {
		return err
	}
	
	// 再设置本地缓存
	return dc.localCache.Set(key, value)
}

高级特性

1. 自定义序列化

// 使用JSON序列化存储结构体
type User struct {
	ID   int
	Name string
}

func setUser(cache *bcache.BigCache, key string, user User) error {
	data, err := json.Marshal(user)
	if err != nil {
		return err
	}
	return cache.Set(key, data)
}

func getUser(cache *bcache.BigCache, key string) (User, error) {
	data, err := cache.Get(key)
	if err != nil {
		return User{}, err
	}
	
	var user User
	err = json.Unmarshal(data, &user)
	return user, err
}

2. 缓存统计

stats := cache.Stats()
fmt.Printf("Hits: %d, Misses: %d, DelHits: %d, DelMisses: %d\n",
	stats.Hits, stats.Misses, stats.DelHits, stats.DelMisses)

最佳实践

1. 合理配置分片数：Shards数量应根据预期缓存大小和并发量设置，通常1024是个不错的起点

2. 设置适当的过期时间：LifeWindow应根据业务需求设置，避免内存无限增长

3. 处理缓存穿透：对于不存在的键，可以在缓存中设置空值标记

4. 批量操作优化：对于批量操作，考虑使用pipeline

5. 监控缓存命中率：定期检查stats，优化缓存策略

bcache作为本地缓存性能极高，在分布式环境中通常作为一级缓存使用，配合Redis等持久化存储实现多级缓存架构，既能保证性能又能确保数据的最终一致性。