一文搞懂Redis击穿/穿透/雪崩&实战

// CacheStrategy 缓存策略接口
type CacheStrategy interface {
    // Get 获取缓存数据，如果缓存不存在则调用loader加载数据
    Get(key string, loader func() (interface{}, error)) (interface{}, error)
    // GetWithLock 获取缓存数据，使用本地锁防止缓存击穿
    GetWithLock(key string, loader func() (interface{}, error), expiration time.Duration) (interface{}, error)
    // Set 设置缓存数据
    Set(key string, value interface{}, expiration time.Duration) error
    // Delete 删除缓存数据
    Delete(key string) error
    // SetEmptyValue 设置空值缓存，防止缓存穿透
    SetEmptyValue(key string) error
}

package goodsRedis

import (
"errors"
"math/rand"
"sync"
"time"

"github.com/gogf/gf/v2/os/gcache"
)

// 常量定义
const (
// EmptyValue 空值标记，用于防止缓存穿透
 EmptyValue = "__EMPTY__"
// EmptyValueExpiration 空值缓存的过期时间
 EmptyValueExpiration = time.Minute * 5
// DefaultExpiration 默认缓存过期时间
 DefaultExpiration = time.Hour
// JitterPercent 随机过期时间的抖动百分比范围
 JitterMinPercent = 5
 JitterMaxPercent = 15
)

// CacheStrategy 缓存策略接口
type CacheStrategy interface {
// Get 获取缓存数据，如果缓存不存在则调用loader加载数据
 Get(key string, loader func() (interface{}, error)) (interface{}, error)
// GetWithLock 获取缓存数据，使用本地锁防止缓存击穿
 GetWithLock(key string, loader func() (interface{}, error), expiration time.Duration) (interface{}, error)
// Set 设置缓存数据
 Set(key string, value interface{}, expiration time.Duration) error
// Delete 删除缓存数据
 Delete(key string) error
// SetEmptyValue 设置空值缓存，防止缓存穿透
 SetEmptyValue(key string) error
}

// RedisCacheStrategy Redis缓存策略实现
type RedisCacheStrategy struct {
 cache *gcache.Cache
 locks sync.Map // 使用sync.Map存储锁对象，键为缓存键，值为互斥锁
}

// NewRedisCacheStrategy 创建新的Redis缓存策略实例
func NewRedisCacheStrategy(cache *gcache.Cache) *RedisCacheStrategy {
return &RedisCacheStrategy{
  cache: cache,
 }
}

// Get 获取缓存数据
func (s *RedisCacheStrategy) Get(key string, loader func() (interface{}, error)) (interface{}, error) {
// 尝试从缓存获取数据
 value, err := s.cache.Get(key)
if err == nil {
// 检查是否是空值标记
if str, ok := value.(string); ok && str == EmptyValue {
   returnnil, errors.New("empty value")
  }
return value, nil
 }

// 缓存未命中，调用loader加载数据
if loader != nil {
return loader()
 }

returnnil, errors.New("cache miss and no loader provided")
}

// GetWithLock 获取缓存数据，使用本地锁防止缓存击穿
func (s *RedisCacheStrategy) GetWithLock(key string, loader func() (interface{}, error), expiration time.Duration) (interface{}, error) {
// 第一次检查缓存
 value, err := s.cache.Get(key)
if err == nil {
// 检查是否是空值标记
if str, ok := value.(string); ok && str == EmptyValue {
   returnnil, errors.New("empty value")
  }
return value, nil
 }

// 获取锁对象
 lock, _ := s.locks.LoadOrStore(key, &sync.Mutex{})
 mutex := lock.(*sync.Mutex)
 mutex.Lock()
defer mutex.Unlock()

// 双重检查，防止在获取锁的过程中缓存被其他线程更新
 value, err = s.cache.Get(key)
if err == nil {
// 检查是否是空值标记
if str, ok := value.(string); ok && str == EmptyValue {
   returnnil, errors.New("empty value")
  }
return value, nil
 }

// 缓存仍未命中，调用loader加载数据
if loader != nil {
  data, err := loader()
if err != nil {
   // 如果loader返回错误，设置空值缓存防止缓存穿透
   s.SetEmptyValue(key)
   returnnil, err
  }

// 如果数据不为空，设置缓存
if data != nil {
   // 添加随机过期时间，防止缓存雪崩
   s.Set(key, data, s.getExpirationWithJitter(expiration))
  } else {
   // 数据为空，设置空值缓存
   s.SetEmptyValue(key)
  }

return data, nil
 }

returnnil, errors.New("cache miss and no loader provided")
}

// Set 设置缓存数据
func (s *RedisCacheStrategy) Set(key string, value interface{}, expiration time.Duration) error {
return s.cache.Set(key, value, expiration)
}

// Delete 删除缓存数据
func (s *RedisCacheStrategy) Delete(key string) error {
// 删除缓存
 err := s.cache.Remove(key)
if err != nil {
return err
 }

// 移除对应的锁对象
 s.locks.Delete(key)
returnnil
}

// SetEmptyValue 设置空值缓存，防止缓存穿透
func (s *RedisCacheStrategy) SetEmptyValue(key string) error {
return s.cache.Set(key, EmptyValue, EmptyValueExpiration)
}

// getExpirationWithJitter 计算带随机抖动的过期时间，防止缓存雪崩
func (s *RedisCacheStrategy) getExpirationWithJitter(base time.Duration) time.Duration {
// 如果基础时间小于0，使用默认过期时间
if base <= 0 {
  base = DefaultExpiration
 }

// 生成5%-15%之间的随机百分比
 jitter := rand.Intn(JitterMaxPercent-JitterMinPercent+1) + JitterMinPercent
 jitterDuration := time.Duration(jitter) * base / 100

// 添加随机抖动到基础时间
return base + jitterDuration
}

// DelayedDelete 延迟删除缓存，用于延迟双删策略
func (s *RedisCacheStrategy) DelayedDelete(key string, delay time.Duration) {
gofunc() {
  time.Sleep(delay)
  s.Delete(key)
 }()
}

// GetDetail 获取商品详情
func (c *GoodsInfoController) GetDetail(ctx context.Context, req *v1.GoodsDetailReq) (res *v1.GoodsDetailRes, err error) {
// 获取商品ID
 goodsId := req.Id

// 构建缓存键
 cacheKey := GetGoodsDetailKey(goodsId)

// 创建缓存策略实例
 cacheStrategy := NewRedisCacheStrategy(GetCache())

// 使用缓存策略获取数据，带锁防止缓存击穿
 goodsDetail, err := cacheStrategy.GetWithLock(
  cacheKey,
// loader函数：从数据库获取数据
func() (interface{}, error) {
   return c.GetDetailFromDB(ctx, goodsId)
  },
// 基础过期时间：1小时
  DefaultExpiration,
 )

// 处理错误
if err != nil {
if err.Error() == "empty value" {
   // 空值缓存，直接返回商品不存在
   returnnil, gerror.New("商品不存在")
  }
returnnil, err
 }

// 将结果转换为响应格式
if detail, ok := goodsDetail.(*v1.GoodsDetailRes); ok {
return detail, nil
 }

returnnil, gerror.New("数据格式错误")
}

// GetDetailFromDB 从数据库获取商品详情
func (c *GoodsInfoController) GetDetailFromDB(ctx context.Context, goodsId int) (*v1.GoodsDetailRes, error) {
// 从数据库查询商品信息
 goodsInfo, err := c.goodsInfoService.FindOne(ctx, goodsId)
if err != nil {
returnnil, err
 }

if goodsInfo == nil {
returnnil, gerror.New("商品不存在")
 }

// 构建响应数据
 res := &v1.GoodsDetailRes{
  Id:          goodsInfo.Id,
  Title:       goodsInfo.Title,
  Price:       goodsInfo.Price,
  OriginalPrice: goodsInfo.OriginalPrice,
  Description: goodsInfo.Description,
// 其他字段...
 }

return res, nil
}

// GetGoodsDetailKey 获取商品详情缓存键
func GetGoodsDetailKey(goodsId int) string {
 return fmt.Sprintf("goods:detail:%d", goodsId)
}

// GetCategoryInfoKey 获取分类信息缓存键
func GetCategoryInfoKey(categoryId int) string {
 return fmt.Sprintf("category:info:%d", categoryId)
}

var (
// cache 缓存实例
 cache *gcache.Cache
)

// InitRedisCache 初始化Redis缓存
func InitRedisCache() error {
// 从配置获取Redis连接信息
 host := g.Cfg().MustGet(ctx, "redis.host").String()
 port := g.Cfg().MustGet(ctx, "redis.port").String()
 password := g.Cfg().MustGet(ctx, "redis.password").String()
 db := g.Cfg().MustGet(ctx, "redis.db").Int()

// 创建Redis实例
 redisClient := gredis.New(gredis.Config{
  Host:     host,
  Port:     port,
  Password: password,
  DB:       db,
 })

// 测试连接
if err := redisClient.Ping(ctx); err != nil {
return err
 }

// 初始化gcache的Redis适配器
 cache = gcache.New()
 cache.SetAdapter(gcache.NewAdapterRedis(redisClient))

returnnil
}

// GetCache 获取缓存实例
func GetCache() *gcache.Cache {
return cache
}

// Update 更新商品信息
func (c *GoodsInfoController) Update(ctx context.Context, req *v1.GoodsUpdateReq) error {
// 更新数据库
 err := c.goodsInfoService.Update(ctx, req)
if err != nil {
return err
 }

// 构建缓存键
 cacheKey := GetGoodsDetailKey(req.Id)
 cacheStrategy := NewRedisCacheStrategy(GetCache())

// 第一次删除缓存
 err = cacheStrategy.Delete(cacheKey)
if err != nil {
  log.Errorf("第一次删除缓存失败: %v", err)
 }

// 延迟100毫秒后再次删除缓存
 cacheStrategy.DelayedDelete(cacheKey, 100*time.Millisecond)

returnnil
}