SYSTEM
实现文章发布异步生成 AI 摘要(发布后不阻塞,等摘要生成完再更新)
src/content/notes/blog-dev/实现文章发布异步生成-AI-摘要-发布后不阻塞,等摘要生成完再更新.md 实现文章发布异步生成 AI 摘要(发布后不阻塞,等摘要生成完再更新)
- 预期效果:发布文章后立即返回(前端不等待),摘要异步生成后自动更新
步骤:
1.新建 DTO:SummaryGenerateMessage.java(dto 包)
package com.blog.blog.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class SummaryGenerateMessage implements Serializable {
private Long articleId;
private Long timestamp;
}
2. 修改 RabbitMQConfig.java(新增部分)
// ============ 摘要生成交换机/队列 ============
public static final String SUMMARY_EXCHANGE = "blog.summary.exchange";
public static final String SUMMARY_QUEUE = "blog.summary.queue";
public static final String SUMMARY_ROUTING_KEY = "blog.summary.generate";
public static final String SUMMARY_DLX_EXCHANGE = "blog.summary.dlx.exchange";
public static final String SUMMARY_DLX_QUEUE = "blog.summary.dlx.queue";
@Bean
public TopicExchange summaryExchange() {
return new TopicExchange(SUMMARY_EXCHANGE, true, false); // durable=true
}
@Bean
public Queue summaryQueue() {
return QueueBuilder.durable(SUMMARY_QUEUE)
.withArgument("x-dead-letter-exchange", SUMMARY_DLX_EXCHANGE)
.withArgument("x-dead-letter-routing-key", SUMMARY_DLX_QUEUE)
.build();
}
@Bean
public Binding summaryBinding() {
return BindingBuilder.bind(summaryQueue())
.to(summaryExchange())
.with(SUMMARY_ROUTING_KEY);
}
// 死信交换机 + 死信队列
@Bean
public TopicExchange summaryDlxExchange() {
return new TopicExchange(SUMMARY_DLX_EXCHANGE, true, false);
}
@Bean
public Queue summaryDlxQueue() {
return QueueBuilder.durable(SUMMARY_DLX_QUEUE).build();
}
@Bean
public Binding summaryDlxBinding() {
return BindingBuilder.bind(summaryDlxQueue())
.to(summaryDlxExchange())
.with(SUMMARY_DLX_QUEUE);
}
3. 修改 ArticleServiceImpl.createArticle
@Autowired
private RabbitTemplate rabbitTemplate;
@Override
public Article createArticle(String title, String content, Long userId, String categoryId) {
Article article = new Article();
article.setTitle(title);
article.setContent(content);
article.setUserId(userId);
article.setCategoryId(categoryId);
article.setCreateTime(LocalDateTime.now());
article.setUpdateTime(LocalDateTime.now());
article.setSummary("AI 摘要生成中..."); // 前端显示默认值
article = articleRepository.save(article);
// 布隆过滤器(不能漏!)
bloomFilterUtil.add(article.getId());
// MQ 异步生成摘要(失败降级不影响主流程)
try {
SummaryGenerateMessage msg = new SummaryGenerateMessage();
msg.setArticleId(article.getId());
msg.setTimestamp(System.currentTimeMillis());
rabbitTemplate.convertAndSend(
RabbitMQConfig.SUMMARY_EXCHANGE,
RabbitMQConfig.SUMMARY_ROUTING_KEY,
msg
);
} catch (Exception e) {
log.warn("发送摘要生成消息失败,articleId={},降级为同步生成", article.getId(), e);
// MQ 不可用时降级:同步生成摘要,保底用户体验
try {
String summary = deepSeekService.generateSummary(content);
article.setSummary(summary);
article = articleRepository.save(article);
} catch (Exception ex) {
log.error("同步摘要生成也失败,articleId={}", article.getId(), ex);
}
}
// 全量删缓存(Bug2+Bug3 修复)
clearRelatedCaches(article.getId());
return article;
}
4. 新建 SummaryConsumer.java(service 包)
package com.blog.blog.service;
import com.blog.blog.config.RabbitMQConfig;
import com.blog.blog.dto.SummaryGenerateMessage;
import com.blog.blog.entity.Article;
import com.blog.blog.repository.ArticleRepository;
import com.blog.blog.service.impl.ArticleServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@Component
public class SummaryConsumer {
private static final Logger log = LoggerFactory.getLogger(SummaryConsumer.class);
@Autowired
private ArticleRepository articleRepository;
@Autowired
private DeepSeekService deepSeekService;
@Autowired
private ArticleServiceImpl articleService; // 为了调 clearRelatedCaches(需要反射或抽出工具类,这里简化)
// 常量同 ArticleServiceImpl,实际建议抽到公共常量类
private static final String ARTICLE_DETAIL_KEY = "blog:article:detail:";
private static final String ARTICLE_LIST_KEY = "blog:article:list";
private static final String ARTICLE_LIST_PAGE_KEY = "blog:article:list:page:";
private static final String ARTICLE_TOTAL_COUNT_KEY = "blog:article:total:count";
private static final String ARTICLE_RANKING_VIEWS_KEY = "blog:article:ranking:views";
private static final String ARTICLE_RANKING_LATEST_KEY = "blog:article:ranking:latest";
@Autowired
private com.blog.blog.common.util.RedisUtil redisUtil;
@RabbitListener(queues = RabbitMQConfig.SUMMARY_QUEUE)
public void handleSummaryGeneration(SummaryGenerateMessage message) {
Long articleId = message.getArticleId();
log.info("开始异步生成文章摘要,articleId={}", articleId);
// TODO: 幂等性检查(SETNX,去重)
Article article;
try {
article = articleRepository.findById(articleId)
.orElseThrow(() -> new IllegalArgumentException("文章不存在:" + articleId));
} catch (IllegalArgumentException e) {
// 不可重试异常:ACK + 告警,不进入死信
log.error("摘要生成失败,文章不存在,articleId={}", articleId, e);
return;
}
// HTTP 调用(事务外)
String summary;
try {
summary = deepSeekService.generateSummary(article.getContent());
} catch (Exception e) {
// 可重试异常:抛出去触发 NACK → 死信队列
log.error("AI 摘要生成失败(可重试),articleId={}", articleId, e);
throw new RuntimeException("摘要生成失败,进入死信队列", e);
}
// DB 操作(事务内)
updateArticleSummary(articleId, summary);
// 删缓存(让下次查询回源,避免竞态条件)
clearRelatedCaches(articleId);
log.info("文章摘要生成完成,articleId={}", articleId);
}
@Transactional
public void updateArticleSummary(Long articleId, String summary) {
Article article = articleRepository.findById(articleId)
.orElseThrow(() -> new IllegalArgumentException("文章不存在:" + articleId));
article.setSummary(summary);
articleRepository.save(article);
}
// 复制同 ArticleServiceImpl.clearRelatedCaches
// 企业规范:这个方法应该抽到公共工具类(如 CacheCleaner),避免重复代码
private void clearRelatedCaches(Long articleId) {
redisUtil.delete(ARTICLE_LIST_KEY);
redisUtil.deleteByPattern(ARTICLE_LIST_PAGE_KEY + "*");
redisUtil.deleteByPattern(ARTICLE_TOTAL_COUNT_KEY + "*");
redisUtil.delete(ARTICLE_DETAIL_KEY + articleId);
redisUtil.delete(ARTICLE_RANKING_VIEWS_KEY);
redisUtil.delete(ARTICLE_RANKING_LATEST_KEY);
}
}
优化:一、消息体简化(不传 content,消费者从 DB 查)
SummaryGenerateMessage 中实现
@Data
public class SummaryGenerateMessage implements Serializable {
private Long articleId; // ✅ 只传 articleId
private Long timestamp; // 幂等去重用
}
二、RestTemplate 超时配置(防止线程卡死)
在 DeepSeekService 中配置超时
package com.blog.blog.service;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import javax.annotation.PostConstruct;
@Service
public class DeepSeekService {
@Value("${deepseek.api.key}")
private String apiKey;
@Value("${deepseek.api.url}")
private String apiUrl;
private RestTemplate restTemplate;
private final ObjectMapper objectMapper = new ObjectMapper();
@PostConstruct
public void init() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
// 连接超时:建立 TCP 握手的最大等待时间(防止目标服务器挂了)
factory.setConnectTimeout(5000); // 5 秒
// 读取超时:发送请求后等待响应的最大时间(AI API 通常 2-30 秒)
factory.setReadTimeout(30000); // 30 秒
this.restTemplate = new RestTemplate(factory);
}
public String generateSummary(String content) {
// ... 原有逻辑不变
}
}
企业规范:超时时间设计原则
| 超时类型 | 推荐值 | 设计理由 |
|---|---|---|
| ConnectTimeout | 3-10 秒 | 网络握手,超过说明目标不可达 |
| ReadTimeout | 业务 P99 × 2 | AI API 正常 5-15 秒,给 30 秒兜底 |
| 超时异常 | 归类为可重试异常 | 网络抖动/超时,重投一次可能就成功 |
application.yml 可配置化(进阶)
deepseek:
api:
key: your-key
url: https://api.deepseek.com/chat/completions
timeout:
connect: 5000
read: 30000
Java 里用 @Value 读取,不改代码调超时。
三、AI 调用限流(防止打爆 API 付费额度)
·方案:Redis 令牌桶 + 消费者并发限制
Redis 令牌桶限流:用 Redis + Lua 实现分布式令牌桶,全局每秒 N 次请求。
新建 RedisRateLimiter.java(common/util 包)
package com.blog.blog.common.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import java.util.Collections;
@Component
public class RedisRateLimiter {
@Autowired
private StringRedisTemplate stringRedisTemplate;
// Lua 脚本:令牌桶算法(原子操作,无并发问题)
// KEYS[1] = 限流 key, ARGV[1] = 桶容量, ARGV[2] = 每秒生成令牌数, ARGV[3] = 当前时间戳(秒)
private static final String TOKEN_BUCKET_SCRIPT =
"local capacity = tonumber(ARGV[1])\n" +
"local rate = tonumber(ARGV[2])\n" +
"local now = tonumber(ARGV[3])\n" +
"local key = KEYS[1]\n" +
"local data = redis.call('HMGET', key, 'tokens', 'lastTime')\n" +
"local tokens = tonumber(data[1]) or capacity\n" +
"local lastTime = tonumber(data[2]) or now\n" +
"local delta = math.max(0, now - lastTime)\n" +
"tokens = math.min(capacity, tokens + delta * rate)\n" +
"if tokens >= 1 then\n" +
" tokens = tokens - 1\n" +
" redis.call('HMSET', key, 'tokens', tokens, 'lastTime', now)\n" +
" redis.call('EXPIRE', key, 86400)\n" +
" return 1\n" +
"else\n" +
" return 0\n" +
"end";
/**
* 尝试获取令牌
* @param key 限流维度(如 "deepseek:summary")
* @param capacity 令牌桶容量(瞬时最大突发)
* @param rate 每秒生成令牌数(长期平均速率)
* @return true=获取到,允许请求;false=限流,拒绝请求
*/
public boolean tryAcquire(String key, int capacity, int rate) {
DefaultRedisScript<Long> script = new DefaultRedisScript<>(TOKEN_BUCKET_SCRIPT, Long.class);
Long nowSeconds = System.currentTimeMillis() / 1000;
Long result = stringRedisTemplate.execute(script,
Collections.singletonList(key),
String.valueOf(capacity),
String.valueOf(rate),
String.valueOf(nowSeconds));
return Long.valueOf(1L).equals(result);
}
}
SummaryConsumer 中使用
@Autowired
private RedisRateLimiter rateLimiter;
@RabbitListener(queues = RabbitMQConfig.SUMMARY_QUEUE)
public void handleSummaryGeneration(SummaryGenerateMessage message) {
Long articleId = message.getArticleId();
// 限流:全局每秒 3 次,突发最多 5 次(按需调整)
boolean allowed = rateLimiter.tryAcquire("deepseek:summary", 5, 3);
if (!allowed) {
log.warn("AI API 限流触发,articleId={},稍后重试", articleId);
// 抛异常 → 进入死信队列,后续手动批量重试
throw new RuntimeException("AI API 限流,进入死信队列,articleId=" + articleId);
}
// ... 后续正常流程
}
消费者并发限制(简单粗暴,不需要限流组件)
在 @RabbitListener 上限制并发数,同时最多 N 个消费者线程在跑 AI 请求。
@RabbitListener(queues = RabbitMQConfig.SUMMARY_QUEUE, concurrency = "2-5")
// concurrency = "2-5" 表示最少 2 个并发,最多 5 个并发(按需调整)
public void handleSummaryGeneration(SummaryGenerateMessage message) {
// ...
}
四、幂等性的具体实现(替换 TODO)
在 SummaryConsumer 中:
@RabbitListener(queues = RabbitMQConfig.SUMMARY_QUEUE)
public void handleSummaryGeneration(SummaryGenerateMessage message) {
Long articleId = message.getArticleId();
log.info("开始异步生成文章摘要,articleId={}", articleId);
// ① 幂等性检查(替换原 TODO)
// key: summary:done:{articleId} → 标记该文章摘要已生成
String doneKey = "blog:summary:done:" + articleId;
Boolean isFirst = redisUtil.setIfAbsent(doneKey, "1", 86400); // 24小时
if (!Boolean.TRUE.equals(isFirst)) {
log.info("摘要已生成,跳过重复消费,articleId={}", articleId);
return; // 直接 ACK,不进入后续流程
}
// ② 限流检查(可选,如果用了令牌桶)
boolean allowed = rateLimiter.tryAcquire("deepseek:summary", 5, 3);
if (!allowed) {
log.warn("AI API 限流,articleId={},稍后重试", articleId);
// 注意:限流时要撤销幂等标记,否则重试时 SETNX 会认为已处理
redisUtil.delete(doneKey);
throw new RuntimeException("AI API 限流,进入死信队列");
}
// ③ 业务逻辑:查文章 → 调 AI → 更新 DB → 删缓存
// ...
}