Redis缓存穿透、缓存击穿、缓存雪崩的区别和解决方案

1
public Object queryById(Long id) {
2
    // 1. 先查缓存
3
    Object cache = redisTemplate.get("user:" + id);
4
    if (cache != null) {
5
        return "".equals(cache) ? null : cache; // 空值缓存直接返回 null
6
    }
7
    // 2. 查数据库
8
    Object user = userMapper.selectById(id);
9
    if (user != null) {
10
        redisTemplate.set("user:" + id, user, 30, TimeUnit.MINUTES);
11
    } else {
12
        // 3. 数据库也没有 → 缓存空值，短过期时间
13
        redisTemplate.set("user:" + id, "", 3, TimeUnit.MINUTES);
14
    }
15
    return user;
16
}

1
// 初始化布隆过滤器（Guava 示例）
2
BloomFilter<Long> bloomFilter = BloomFilter.create(
3
        Funnels.longFunnel(),      // 类型
4
        100_0000,                  // 预计元素数量
5
        0.01);                     // 误判率
6

7
// 初始化时把所有商品/用户 id 预加载进去
8
List<Long> ids = userMapper.selectAllIds();
9
ids.forEach(bloomFilter::put);
10

11
// 查询时先过滤
12
public Object queryById(Long id) {
13
    if (!bloomFilter.mightContain(id)) {
14
        return null; // 一定不存在，直接拦截
15
    }
16
    // ... 正常走缓存流程
17
}

1
public Object queryByIdWithLock(Long id) {
2
    String key = "user:" + id;
3
    Object cache = redisTemplate.get(key);
4
    if (cache != null) {
5
        return cache;
6
    }
7
    String lockKey = "lock:user:" + id;
8
    boolean locked = redisTemplate.opsForValue()
9
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS); // 加锁 + 超时兜底
10
    if (locked) {
11
        try {
12
            // 拿到锁，再查一次缓存（防止等待期间其他线程已回写）
13
            cache = redisTemplate.get(key);
14
            if (cache != null) {
15
                return cache;
16
            }
17
            Object user = userMapper.selectById(id);
18
            redisTemplate.set(key, user, 30, TimeUnit.MINUTES);
19
            return user;
20
        } finally {
21
            // 释放锁（建议配合 Lua 脚本校验 value，防止误删）
22
            redisTemplate.delete(lockKey);
23
        }
24
    } else {
25
        // 没拿到锁，自旋重试
26
        try {
27
            Thread.sleep(50);
28
        } catch (InterruptedException e) {
29
            Thread.currentThread().interrupt();
30
        }
31
        return queryByIdWithLock(id); // 递归重试
32
    }
33
}

1
// 缓存结构：Data = { value, expireTime }
2
@Data
3
class CacheData<T> {
4
    private T data;
5
    private Long expireTime;
6
}
7

8
public T queryByIdWithLogicalExpire(Long id) {
9
    String key = "hot:user:" + id;
10
    CacheData<T> cacheData = (CacheData<T>) redisTemplate.get(key);
11
    if (cacheData == null) {
12
        // 冷数据兜底，走互斥锁查库（略）
13
        return queryFromDb(id);
14
    }
15
    // 1. 逻辑过期时间未到，直接返回
16
    if (cacheData.getExpireTime() > System.currentTimeMillis()) {
17
        return cacheData.getData();
18
    }
19
    // 2. 逻辑过期，先返回旧数据，再异步刷新
20
    executor.submit(() -> refreshCache(id, key));
21
    return cacheData.getData();
22
}