← 返回学习路线

SYSTEM

对目前项目进行计划和实际的对比

后端实战
src/content/notes/blog-dev/对目前项目进行计划和实际的对比.md

对目前项目进行计划和实际的对比

对比 1:缓存整个 Page 对象 vs 拆成 content+total

计划方案(未完成)

redisUtil.set(ARTICLE_LIST_KEY, pageResult, 600);  // 缓存整个 Page 对象

实际方案

redisUtil.set(listKey, pageResult.getContent(), expire);  // 只缓存 content
redisUtil.set(totalKey, pageResult.getTotalElements(), ...);  // 单独缓存 total

理由:

维度 计划方案 实际方案
序列化稳定性 ❌ PageImpl 没有默认构造函数,Jackson 反序列化会报错(你已经踩过这个坑) ✅ List<Article> 和 Long 都是简单类型,序列化稳定
内存效率 ❌ Page 对象包含大量元数据(sort、pageable、number、size 等),冗余 ✅ 只存实际需要的数据,节省内存
灵活性 ❌ 如果需要调整分页参数,整个缓存失效 ✅ content 和 total 可独立管理
企业实践 ⚠️ 少数团队会直接缓存 Page,但更多是拆成独立字段 ✅ 这是企业级实践的标准做法

企业规范结论:拆分缓存是正确选择,计划中的方案在实际生产中会遇到序列化问题。

对比 2:updateArticle/deleteArticle 是否删除详情锁

计划要求

// 修改 updateArticle 和 deleteArticle:删除详情锁(如果存在的话)

实际方案

clearRelatedCaches 没有清理 article:lock{id}

不需要刻意删除锁,理由:

维度 计划方案 实际方案
锁的生命周期 试图手动删除 依赖 TTL 自动过期(10秒)
正确性 ⚠️ 可能误删别人的锁(如果锁已被其他线程获取) ✅ 锁有 TTL,到期自动释放,安全
复杂性 需要额外处理锁的 key 格式和线程安全 ✅ 无需额外逻辑,简化代码
企业实践 ⚠️ 少数场景需要,但不是标准做法 ✅ 这是分布式锁的标准模式

关键逻辑:

  • 你的锁设置了 10 秒 TTL(第171行)
  • 正常情况下,锁在 finally 块中通过 Lua 脚本安全释放(第199行)
  • 即使异常情况(服务宕机),10 秒后锁也会自动过期
  • 更新/删除文章时,锁大概率已经释放了(因为查询操作很快完成)

企业规范结论:不需要在 clearRelatedCaches 中删除锁,依赖 TTL 自动过期是标准做法,你的实现符合企业规范。

额外亮点

你的代码中还有一些计划里没有但非常符合企业规范的实现:

  1. Lua 脚本安全释放锁(第199行)

    • 计划只说 redisUtil.delete(lockKey),存在误删风险
    • 用了 UNLOCK_SCRIPT Lua 脚本,只有锁的持有者才能删除,这是企业级分布式锁的标准写法
  2. UUID 作为锁 value(第167行)

    • 计划用 "locked" 固定字符串,无法区分锁的持有者
    • 用 UUID.randomUUID().toString(),保证锁的唯一性,配合 Lua 脚本实现安全释放
  3. 随机 TTL 防雪崩(第135行)

    • 在所有缓存写入处都加了随机偏移,这是企业级缓存雪崩防护的必备手段
  4. 空值缓存防穿透(第189行)

    • 计划提到了,但实现更完整("NULL" 标记 + 60秒短过期)

Redis 分布式锁进阶 + 实现幂等性防止重复提交

基于用户 ID 的互斥锁(推荐)

// ArticleController.java
@Autowired
private RedisUtil redisUtil;

@PostMapping("/create")
public Result<Article> create(@RequestBody Article article) {
    Long userId = article.getUserId();
    if (userId == null) {
        return Result.error("用户ID不能为空");
    }
    
    // 锁 key:同一用户同一时间只能创建一篇文章
    String lockKey = "article:create:lock:" + userId;
    String lockValue = UUID.randomUUID().toString();
    
    try {
        boolean locked = redisUtil.tryLock(lockKey, lockValue, 30);  //锁 TTL 5 秒可能不够
        if (!locked) {
            return Result.error("操作太频繁,请稍后重试");
        }
        Article createdArticle = articleService.createArticle(
                article.getTitle(), article.getContent(), 
                userId, article.getCategoryId());
        return Result.success(createdArticle);
    } finally {
        redisUtil.unlock(lockKey, lockValue);
    }
}

优点:

  • 同一用户快速点击只会创建一篇文章
  • 不同用户之间互不影响
  • 实现简单,性能好

RedisUtil 新增方法

// RedisUtil.java 新增
public boolean tryLock(String key, String value, long timeout) {
    return Boolean.TRUE.equals(redisTemplate.opsForValue()
            .setIfAbsent(key, value, timeout, TimeUnit.SECONDS));
}

public boolean unlock(String key, String value) {
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "return redis.call('del', KEYS[1]) else return 0 end";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
    Long result = redisTemplate.execute(redisScript, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);
}

问题

问题 1:unlock 每次调用都 new DefaultRedisScript,性能浪费

位置:RedisUtil.java

public boolean unlock(String key, String value) {
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then ...";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);  // ← 每次创建
    Long result = redisTemplate.execute(redisScript, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);
}

原因:DefaultRedisScript 是线程安全的,可以复用。ArticleServiceImpl 中已经将 UNLOCK_SCRIPT 定义为 static final(第47-50行),RedisUtil 应该采用同样模式。

解决方案:在 RedisUtil 中定义静态常量

private static final DefaultRedisScript<Long> UNLOCK_SCRIPT = new DefaultRedisScript<>(
    "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end",
    Long.class
);

public boolean unlock(String key, String value) {
    Long result = redisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);
}

问题 3:unlock 每次调用都 new DefaultRedisScript,性能浪费

位置:RedisUtil.java

public boolean unlock(String key, String value) {
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then ...";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);  // ← 每次创建
    Long result = redisTemplate.execute(redisScript, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);
}

原因:DefaultRedisScript 是线程安全的,可以复用。ArticleServiceImpl 中已经将 UNLOCK_SCRIPT 定义为 static final(第47-50行),RedisUtil 应该采用同样模式。

解决方案:在 RedisUtil 中定义静态常量

private static final DefaultRedisScript<Long> UNLOCK_SCRIPT = new DefaultRedisScript<>(
    "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end",
    Long.class
);

public boolean unlock(String key, String value) {
    Long result = redisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);
}

问题 4:finally 块在 tryLock 失败时也会执行 unlock

位置:ArticleController.java

try {
    boolean locked = redisUtil.tryLock(lockKey, lockValue, 5);
    if (!locked) {
        return Result.error("操作太频繁");  // ← 这里 return 会触发 finally
    }
    // 创建文章...
} finally {
    redisUtil.unlock(lockKey, lockValue);  // ← tryLock 失败时也会执行
}

原因:虽然 Lua 脚本会检查 value 匹配,不会误删别人的锁,但语义不清晰——没拿到锁却去释放锁。

解决方案:把 unlock 放到拿到锁之后的内部 try-finally

boolean locked = redisUtil.tryLock(lockKey, lockValue, 5);
if (!locked) {
    return Result.error("操作太频繁,请稍后重试");
}
try {
    Article createdArticle = articleService.createArticle(...);
    return Result.success(createdArticle);
} finally {
    redisUtil.unlock(lockKey, lockValue);
}

最终效果

场景一:幂等性防止重复提交(创建文章)

代码位置

文件 行号 作用
RedisUtil.java tryLock 方法 加锁
RedisUtil.java UNLOCK_SCRIPT + unlock 方法 安全释放锁
ArticleController.java create 方法 幂等性控制

逐行解析

1. RedisUtil — 分布式锁底层封装

// 加锁:SET key value NX EX timeout(原子操作)
public boolean tryLock(String key, String value, long timeout) {
    return Boolean.TRUE.equals(redisTemplate.opsForValue()
            .setIfAbsent(key, value, timeout, TimeUnit.SECONDS));
    // setIfAbsent = Redis 的 SETNX 命令,key 不存在才写入
    // 同时设置过期时间,保证加锁 + 过期是原子操作(防止死锁)
}
// 释放锁:Lua 脚本保证"判断 value + 删除 key"是原子操作
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT = new DefaultRedisScript<>(
    "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end",
    Long.class
);
//   KEYS[1] = lockKey    → 要释放的锁
//   ARGV[1] = lockValue  → 调用者的唯一标识(UUID)
//   逻辑:只有锁的 value 匹配时才删除,防止误删别人的锁

public boolean unlock(String key, String value) {
    Long result = redisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(key), value);
    return Long.valueOf(1).equals(result);  // 返回 1 = 删除成功,0 = 锁不属于你
}

2. ArticleController — 幂等性控制

@PostMapping("/create")
public Result<Article> create(@RequestBody Article article) {
    Long userId = article.getUserId();
    if (userId == null) {
        return Result.error("用户ID不能为空");           // ① 前置校验
    }

    String lockKey = "article:create:lock:" + userId;    // ② 锁粒度:同一用户互斥
    String lockValue = UUID.randomUUID().toString();     // ③ 唯一标识,用于安全释放锁

    boolean locked = redisUtil.tryLock(lockKey, lockValue, 30);  // ④ 加锁,30秒过期
    if (!locked) {
        return Result.error("操作太频繁,请稍后重试");     // ⑤ 拿不到锁 = 正在创建中,拒绝
    }
    try {
        Article createdArticle = articleService.createArticle(   // ⑥ 执行业务
                article.getTitle(), article.getContent(),
                userId, article.getCategoryId());
        return Result.success(createdArticle);
    } finally {
        redisUtil.unlock(lockKey, lockValue);            // ⑦ 业务完成后释放锁
    }
}

幂等性流程图

用户快速点击两次"发布文章"
         │
         ├── 请求A:tryLock("article:create:lock:1", uuid-A, 30) → ✅ 拿到锁
         │     └── 执行 createArticle → 释放锁
         │
         └── 请求B(50ms后):tryLock("article:create:lock:1", uuid-B, 30) → ❌ 锁已存在
               └── 返回"操作太频繁,请稍后重试"

场景二:缓存击穿防护(查询文章详情)

代码位置

文件 行号 作用
ArticleServiceImpl.java getArticle 方法 防止热点 key 过期瞬间大量请求打到数据库

逐行解析

@Override
public Article getArticle(Long id) {
    String key = ARTICLE_DETAIL_KEY_PREFIX + id;

    // 第150行:1. 先从缓存查
    Object cacheObj = redisUtil.get(key);
    if (cacheObj != null) {
        if ("NULL".equals(cacheObj)) {           // 空值标记防穿透
            throw new RuntimeException("文章不存在");
        }
        return (Article) cacheObj;               // 缓存命中,直接返回
    }

    // 第160-161行:2. 缓存未命中,加分布式锁防击穿
    String lockKey = "article:lock:" + id;
    String lockValue = UUID.randomUUID().toString();  // 唯一标识
    int retryCount = 0;

    while (retryCount < 3) {
        Boolean locked = redisUtil.setIfAbsent(lockKey, lockValue, 10);  // 3. 尝试加锁

        if (Boolean.TRUE.equals(locked)) {
            try {
                // 第170行:4. 二次检查(Double Check)
                cacheObj = redisUtil.get(key);
                if (cacheObj != null) { return (Article) cacheObj; }

                // 第179行:5. 只有一个线程能走到这里查数据库
                Article article = articleRepository.findById(id)...;

                // 第189行:6. 写入缓存
                redisUtil.set(key, article, expire);
                return article;
            } finally {
                // 第193行:7. 安全释放锁
                redisUtil.unlock(lockKey, lockValue);
            }
        }

        // 第198-203行:8. 没拿到锁,等待50ms后重试
        Thread.sleep(50);
        retryCount++;
    }

    // 第207行:9. 重试3次失败,直接查数据库(兜底)
    return articleRepository.findById(id)...;
}

缓存击穿防护流程图

热点文章缓存过期瞬间,100个请求同时到达
         │
         ├── 请求1:tryLock → ✅ 拿到锁 → 查数据库 → 写缓存 → 释放锁
         │
         ├── 请求2~100:tryLock → ❌ 拿不到锁 → sleep(50ms) → 重试
         │     ├── 重试时缓存已被请求1写入 → 命中缓存,直接返回
         │     └── 不会打到数据库
         │
         └── 数据库只被请求1访问一次(而不是100次)