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 自动过期是标准做法,你的实现符合企业规范。
额外亮点
你的代码中还有一些计划里没有但非常符合企业规范的实现:
-
Lua 脚本安全释放锁(第199行)
- 计划只说
redisUtil.delete(lockKey),存在误删风险 - 用了
UNLOCK_SCRIPTLua 脚本,只有锁的持有者才能删除,这是企业级分布式锁的标准写法
- 计划只说
-
UUID 作为锁 value(第167行)
- 计划用
"locked"固定字符串,无法区分锁的持有者 - 用
UUID.randomUUID().toString(),保证锁的唯一性,配合 Lua 脚本实现安全释放
- 计划用
-
随机 TTL 防雪崩(第135行)
- 在所有缓存写入处都加了随机偏移,这是企业级缓存雪崩防护的必备手段
-
空值缓存防穿透(第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次)