← 返回学习路线

SYSTEM

完整实现方案

后端实战三、完整实现方案blog-dev
src/content/notes/blog-dev/完整实现方案.md

三、完整实现方案

第 1 步:加依赖

pom.xml,在 Redis 依赖下面加:

<!-- Redisson(内置布隆过滤器 + 更强大的分布式锁) -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.27.0</version>
</dependency>

第 2 步:Redisson 配置

新建 com/blog/blog/config/RedissonConfig.java:

package com.blog.blog.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {

    @Value("${spring.data.redis.host}")
    private String redisHost;
    
    @Value("${spring.data.redis.port}")
    private int redisPort;
    
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://" + redisHost + ":" + redisPort);
        return Redisson.create(config);
    }
}

第 3 步:布隆过滤器工具类 + 初始化

新建 com/blog/blog/common/BloomFilterUtil.java:

package com.blog.blog.common;

import jakarta.annotation.PostConstruct;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class BloomFilterUtil {

    private static final String BLOOM_FILTER_KEY = "article:bloom";
    private static final long EXPECTED_INSERTIONS = 10000L;  // 预期 1 万篇文章
    private static final double FALSE_PROBABILITY = 0.01;    // 1% 误判率

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private com.blog.blog.repository.ArticleRepository articleRepository;

    private RBloomFilter<Long> bloomFilter;

    /**
     * 项目启动时初始化布隆过滤器
     * 把数据库里所有文章 ID 加载进去
     */
    @PostConstruct
    public void init() {
        bloomFilter = redissonClient.getBloomFilter(BLOOM_FILTER_KEY);
        // 初始化:只有第一次才会创建,已存在就直接用
        bloomFilter.tryInit(EXPECTED_INSERTIONS, FALSE_PROBABILITY);

        // ⚠️ 关键:全量加载现有文章 ID
        // 如果布隆过滤器刚创建(里面是空的),才加载
        // 避免重复加载浪费性能(用 count 判断近似数量)
        if (bloomFilter.count() == 0) {
            List<Long> allIds = articleRepository.findAllIds();
            for (Long id : allIds) {
                bloomFilter.add(id);
            }
            System.out.println("✅ 布隆过滤器初始化完成,加载文章数量:" + allIds.size());
        }
    }

    /**
     * 添加文章 ID
     */
    public void add(Long articleId) {
        bloomFilter.add(articleId);
    }

    /**
     * 判断文章 ID 是否可能存在
     * true  = 可能存在(有误判概率)
     * false = 一定不存在(100% 准确)
     */
    public boolean mightContain(Long articleId) {
        return bloomFilter.contains(articleId);
    }
}

第 4 步:Repository 加一个查 ID 的方法

在 ArticleRepository.java 里加:

/**
 * 查询所有文章 ID(给布隆过滤器初始化用)
 */
@Query("SELECT a.id FROM Article a")
List<Long> findAllIds();

第 5 步:ArticleServiceImpl 接入布隆过滤器

5.1 注入 BloomFilterUtil

ArticleServiceImpl.java 第 33 行附近加:

@Autowired
private BloomFilterUtil bloomFilterUtil;

5.2 createArticle 里 add

在 createArticle 方法的 save 之后加:

article = articleRepository.save(article);

// 新增文章后,把 ID 加入布隆过滤器
bloomFilterUtil.add(article.getId());

redisUtil.delete(ARTICLE_LIST_KEY);

5.3 getArticle 里先判断

在 getArticle 方法的最开头(查缓存之前)加:

public Article getArticle(Long id) {
    // 第 0 关:布隆过滤器 —— 不存在的 ID 直接拦截,不查缓存不查库
    if (!bloomFilterUtil.mightContain(id)) {
        throw new RuntimeException("文章不存在");
    }

    // ... 原来的缓存查询 + DB 查询逻辑不变
}

四、改造后的完整请求流程

请求 GET /api/article/{id}
   │
   ▼
【第0关】布隆过滤器
   ├── 一定不存在 → 直接返回"文章不存在" ← 穿透被拦住!
   └── 可能存在 → 继续 ↓
   │
   ▼
【第1关】Redis 缓存
   ├── 命中 → 直接返回
   ├── 空值标记(NULL) → 返回"不存在"
   └── 未命中 → 继续 ↓
   │
   ▼
【第2关】分布式锁(防击穿)
   ├── 拿到锁 → 二次检查缓存 → 查 DB → 写缓存 → 释放锁
   └── 没拿到锁 → 重试 → 等缓存填好直接读
   │
   ▼
【第3关】MySQL 数据库
   ├── 查到 → 写缓存 → 返回
   └── 没查到 → 缓存空值 → 返回"不存在"

三层防护:

  1. 布隆过滤器:拦住不存在的 ID(防穿透,第一道防线)
  2. 空值缓存:拦住重复查询不存在的 ID(防穿透,第二道防线)
  3. 分布式锁 + DCL:防止热点 key 过期瞬间打垮 DB(防击穿)

五、几个容易踩的坑

1:不做初始化(最严重)

只在 createArticle 里 add,项目一重启布隆过滤器是空的,所有文章都被认为”不存在”,全站 404。

✅ 解决:@PostConstruct 里全量加载。

2:误判率设太低或太高

  • 误判率太低(如 0.0001%)→ 需要更多内存和哈希函数,性能差
  • 误判率太高(如 10%)→ 太多请求漏过去,防穿透效果差

✅ 建议:博客项目 1% 完全够用。1% 的意思是:100 个不存在的 ID,有 1 个会漏过去查数据库,但有 99 个被拦住了。

3:预期数量设小了

布隆过滤器的位数组大小是在 tryInit 时就定死的。如果实际文章数超过预期,误判率会急剧上升。

✅ 建议:博客设 1 万篇绰绰有余。如果未来真的超过了,就重新创建一个容量更大的。

4:删除文章不同步布隆过滤器

布隆过滤器不支持删除元素(这是它的特性)。如果你删了一篇文章,布隆过滤器里还留着它的 ID,会导致:

文章已删除,但布隆过滤器说"可能存在"
  → 请求继续走到缓存和 DB
  → DB 查不到,返回"不存在"
  → 没大问题,就是多查了一次 DB

✅ 影响:不严重,就是一点点性能损失。博客项目删除操作少,不用管。如果非要解决,需要用「布隆过滤器重建」或「计数布隆过滤器」,但复杂度很高。

六、面试时怎么讲

我项目里的缓存穿透问题有两层防护。第一层是布隆过滤器,用 Redisson 实现,项目启动时把所有文章 ID 加载进去,查询时先过布隆过滤器,不存在的 ID 直接返回,不查数据库,能拦住 99% 的穿透请求。第二层是空值缓存,布隆过滤器误判漏过去的请求,查 DB 没查到就缓存一个空标记,短过期时间,防止同一个不存在的 ID 被重复刷。两层加一起,基本杜绝了缓存穿透问题。

新优化