4. 缓存穿透原理与解决方案：布隆过滤器原理、RedisBloom模块安装与使用、代码级防穿透

4.1 缓存穿透：定义与危害

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，导致每次请求都直接穿透缓存层，落到后端数据库上。由于缓存无法命中，大量恶意或异常请求会直接压垮数据库，造成系统雪崩。

4.2 布隆过滤器原理

布隆过滤器（Bloom Filter）是一种空间效率极高的概率型数据结构，用于判断一个元素一定不存在或可能存在于集合中。其核心思想是：使用多个哈希函数将元素映射到一个位数组上，通过位状态快速过滤掉不存在的数据。

4.3 RedisBloom 模块安装与使用

RedisBloom 是 Redis 官方提供的布隆过滤器扩展模块，提供了 BF.ADD、BF.EXISTS、BF.RESERVE 等命令，支持自定义容量和误判率。

4.3.1 安装方式

4.3.2 核心命令示例

# 1. 创建布隆过滤器：容量 10000，误判率 0.01（1%）
BF.RESERVE user_bloom 0.01 10000

# 2. 添加元素
BF.ADD user_bloom user:1001
BF.ADD user_bloom user:1002
BF.ADD user_bloom user:1003

# 3. 批量添加
BF.MADD user_bloom user:1004 user:1005 user:1006

# 4. 检查元素是否存在
BF.EXISTS user_bloom user:1001    # (integer) 1
BF.EXISTS user_bloom user:9999    # (integer) 0

# 5. 批量检查
BF.MEXISTS user_bloom user:1001 user:9999  # 1) (integer) 1  2) (integer) 0

# 6. 获取过滤器信息
BF.INFO user_bloom

4.4 代码级防穿透：Java 实战

以下代码展示了在 Spring Boot 项目中，结合 RedisBloom 实现缓存穿透防护的完整方案。

4.4.1 布隆过滤器工具类

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import org.springframework.stereotype.Component;

@Component
public class BloomFilterUtil {

    private final JedisPool jedisPool;

    public BloomFilterUtil(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 创建布隆过滤器
     * @param filterName 过滤器名称
     * @param capacity   预期容量
     * @param errorRate  误判率（0~1）
     */
    public void createFilter(String filterName, long capacity, double errorRate) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.sendCommand(
                Protocol.Command.valueOf("BF.RESERVE"),
                filterName,
                String.valueOf(errorRate),
                String.valueOf(capacity)
            );
        }
    }

    /**
     * 添加元素
     */
    public void add(String filterName, String element) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.sendCommand(
                Protocol.Command.valueOf("BF.ADD"),
                filterName,
                element
            );
        }
    }

    /**
     * 判断元素是否存在
     * @return true=可能存在，false=一定不存在
     */
    public boolean mightContain(String filterName, String element) {
        try (Jedis jedis = jedisPool.getResource()) {
            Object result = jedis.sendCommand(
                Protocol.Command.valueOf("BF.EXISTS"),
                filterName,
                element
            );
            return "1".equals(result.toString());
        }
    }
}

4.4.2 业务层防穿透实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private BloomFilterUtil bloomFilterUtil;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private UserMapper userMapper;

    private static final String BLOOM_FILTER_KEY = "user_bloom_filter";
    private static final String CACHE_KEY_PREFIX = "user:";

    /**
     * 查询用户信息（防穿透版本）
     */
    public User getUserById(Long userId) {
        String key = CACHE_KEY_PREFIX + userId;

        // 第一步：布隆过滤器拦截
        if (!bloomFilterUtil.mightContain(BLOOM_FILTER_KEY, key)) {
            // 一定不存在，直接返回空，避免穿透
            return null;
        }

        // 第二步：查询缓存
        User user = (User) redisTemplate.opsForValue().get(key);
        if (user != null) {
            return user;
        }

        // 第三步：查询数据库
        user = userMapper.selectById(userId);
        if (user != null) {
            // 数据存在，写入缓存和布隆过滤器
            redisTemplate.opsForValue().set(key, user, 1, TimeUnit.HOURS);
            bloomFilterUtil.add(BLOOM_FILTER_KEY, key);
        } else {
            // 数据不存在，缓存空值（短过期时间，防止缓存穿透）
            redisTemplate.opsForValue().set(key, new User(), 5, TimeUnit.MINUTES);
        }
        return user;
    }

    /**
     * 初始化布隆过滤器（应用启动时调用）
     */
    @PostConstruct
    public void initBloomFilter() {
        // 预估用户量 100 万，误判率 0.001
        bloomFilterUtil.createFilter(BLOOM_FILTER_KEY, 1_000_000L, 0.001);

        // 预热：将已有用户ID加载到布隆过滤器
        List<Long> allUserIds = userMapper.selectAllIds();
        allUserIds.forEach(id -> {
            bloomFilterUtil.add(BLOOM_FILTER_KEY, CACHE_KEY_PREFIX + id);
        });
    }
}

4.5 多层防护体系对比

4.6 性能指标与监控