SYSTEM
回顾接入DeepSeek API实现AI自动摘要
src/content/notes/blog-dev/回顾接入DeepSeek-API实现AI自动摘要.md 回顾接入DeepSeek API实现AI自动摘要
一.整体流程:
用户在博客创建文章
↓
后端接收到文章内容
↓
调用 DeepSeekService.generateSummary(content)
↓
DeepSeekService 构造 HTTP 请求 → 调用 DeepSeek API
↓
DeepSeek API 返回摘要结果
↓
将摘要存入 Article 对象的 summary 字段
↓
保存文章到数据库
二.核心逻辑代码编写:
1.在pom.xml中添加:
<!--API接口-->
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.12.0</version>
</dependency>
2.appliaction.properties新增配置:
deepseek.api.key=[密钥已隐藏] #你的deepseek api
deepseek.api.url=https://api.deepseek.com/v1/chat/completions #URL地址
3.Article实体类新增summary字段(摘要存储位置):
@Column(name="summary",length=500)
private String summary;
4.新建DeepSeekService(封装调用API的逻辑):
@Service
public class DeepSeekService {
@Value("${deepseek.api.key}")
private String apiKey;
@Value("${deepseek.api.url}")
private String apiUrl;
public String generateSummary(String content) {
// 1. 构造请求体(model + messages)
// 2. 设置请求头(Authorization: Bearer API Key)
// 3. 发送 HTTP POST 请求
// 4. 解析响应,提取摘要文本
// 5. 返回摘要
}
}
5.修改ArticleServiceImpl注入DeepSeekService:
@Autowired
private DeepSeekService deepSeekService;
修改createArticle方法:
// 调用 AI 生成摘要
String summary = deepSeekService.generateSummary(content);
article.setSummary(summary);
- 面试回答:分了 5 步:先在配置文件里配好 API Key 和 URL,然后在实体类里加 summary 字段,接着新建一个 DeepSeekService 封装调用 API 的逻辑,最后在 ArticleServiceImpl 里注入 Service,在创建文章时调用生成摘要并存入数据库。
完善JWT
┌────────────────────────────────────────────────────────────────────────┐
│ 后端 Spring Boot │
│ │
│ ┌───────────────┐ ┌────────────────┐ ┌───────────────────┐ │
│ │ SecurityConfig│───▶│ WebMvcConfig │───▶│ JwtInterceptor │ │
│ │ permitAll() │ │ 注册拦截器 │ │ preHandle()校验 │ │
│ └───────────────┘ └────────────────┘ └───────────────────┘ │
│ │ │
│ ┌────────────────────┼──────────┐ │
│ ▼ ▼ ▼ │
│ ① 路径在放行列表 ② 无 token ③ 有 token │
│ 直接放行 ✅ 返回 401 ❌ 解析 userId │
│ 请求放行 ✅ │
└────────────────────────────────────────────────────────────────────────┘
一.核心逻辑代码编写
1. pom.xml — 依赖管理
引入 JWT 库(jjwt)和 Spring Security(用于 BCrypt 密码加密):
<!-- JWT 核心库(JJWT 0.12.6) -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId> <!-- API:Jwts, Claims 等 -->
<version>0.12.6</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId> <!-- 实现类(运行期需要) -->
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId> <!-- JSON 序列化(运行期需要) -->
<version>0.12.6</version>
<scope>runtime</scope>
</dependency>
<!-- Spring Security(只用了 BCryptPasswordEncoder) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
jjwt-api— JWT 的核心 API,提供Jwts、Claims、Keys等类jjwt-impl— JJWT 的实现类(运行期需要)jjwt-jackson— JJWT 的 JSON 序列化支持(运行期需要)
2.application.properties — JWT 配置
# JWT??
jwt.secret-key=MySecretKeyForJWTTokenGeneration2026BlogProject
jwt.expiration-time=86400000
存储JWT配置私密信息,防止被人直接获取用来攻破JWT。
- 定义一个足够长的密钥(至少 256 位,否则 HMAC-SHA256 会报错)
- 定义过期时间(24 小时,单位毫秒)
3. JwtUtil.java — JWT 工具类
拦截 HTTP 请求,校验 token,通过后把 userId 设置到 request 属性
@Component
public class JwtUtil {
private final SecretKey key;
private final long expirationTime;
// 构造方法注入,Spring一定会执行
public JwtUtil(@Value("${jwt.secret-key}") String secretKey,
@Value("${jwt.expiration-time}") long expirationTime) {
if (secretKey == null || secretKey.isBlank()) {
throw new IllegalArgumentException("❌ JWT secret-key 未配置");
}
this.key = Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
this.expirationTime = expirationTime;
System.out.println("✅ JWT Key 初始化成功");
}
// 方法1:生成 token — 用 userId 做 subject,带上签发时间和过期时间
public String generateToken(Long userId) {
return Jwts.builder().subject(userId.toString()) // 把 userId 存入 payload
.issuedAt(new Date()) // 签发时间
.expiration(new Date(System.currentTimeMillis()+expirationTime)) // 过期时间
.signWith(key) // HMAC-SHA256 签名
.compact();
}
// 方法2:解析 token → 取出 userId,从 token 解析出用户 ID
public Long getUserIdFromToken(String token) {
Claims claims = Jwts.parser()
.verifyWith(key)
.build()
.parseSignedClaims(token)
.getPayload();
return Long.parseLong(claims.getSubject());
}
// 方法3:校验 token 是否有效(捕获所有异常,无效就返回 false)
public boolean validateToken(String token) {
try{
Jwts.parser().verifyWith(key)
.build()
.parseClaimsJws(token);
return true;
}catch(Exception e){
return false; // 过期、签名错误、格式错误全部返回 false
}
}
}
- 编写思路:
- 先声明
final字段, JwtUtil:用构造方法注入,@Value封装sertKey和expirationTime;接着空值校验,没配密钥直接启动时报错;Keys.hmacShaKeyFor(...)把字符串密钥转成JJWT能识别的SecretKey对象generateToken:用Jwts.builder()构建 token,把userId.toString()放进subject,设置签发时间issuedAt和过期时间expiration,用signWith(key)签名,最后compact()输出字符串getUserIdFromToken:解析 token 拿Claims,从getSubject()取出 userId 字符串转成 LongvalidateToken:用try-catch包裹——JWT 过期会抛ExpiredJwtException,签名错误会抛SignatureException,格式错误也会抛异常,统一返回false
4. JwtInterceptor.java — JWT 拦截器
拦截 HTTP 请求,校验 token,通过后把 userId 设置到 request 属性
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
String requestURI = request.getRequestURI();
// 第一层:GET 请求的某些详情接口直接放行(不需要 token)
if ("GET".equalsIgnoreCase(method)) {
if (匹配详情路径) return true;
}
// 第二层:取 Authorization 头
String token = request.getHeader("Authorization");
if (token == null || token.isEmpty()) {
response.setStatus(401); // 未登录
return false;
}
// 第三层:校验 token 有效性
if (!jwtUtil.validateToken(token)) {
response.setStatus(401); // token 过期或无效
return false;
}
// 第四层:解析 userId,放到请求属性中供 Controller 使用
Long userId = jwtUtil.getUserIdFromToken(token);
request.setAttribute("userId", userId);
return true;
}
① 请求进来
↓
② 请求是否匹配 GET 绕过路径?(如文章详情、站点配置等公开的 GET 接口)
├─ 是 → 直接放行 ✅
└─ 否 → 进入下一步
↓
③ 请求头中是否携带 Authorization?
├─ 无 → 返回 401 "未登录" ❌
└─ 有 → 进入下一步
↓
④ Token 是否有效?(调用 jwtUtil.validateToken)
├─ 无效 → 返回 401 "token无效或已过期" ❌
└─ 有效 → 进入下一步
↓
⑤ 解析 userId,存入 request.setAttribute("userId", userId)
↓
⑥ 放行 ✅ → Controller 正常处理
- 为什么 GET 路径还要单独绕过?
因为某些详情接口(如查看文章详情
/api/article/1)是公开的,不需要登录也能看。但路径中有动态参数(ID),无法在WebMvcConfig的excludePathPatterns中用精确路径写死,所以用matches()正则匹配。需要登录才能访问的 GET 接口(如/api/article/user/1)不会匹配这些正则,继续走 token 校验。
5. WebMvcConfig.java — 拦截器注册
把 JwtInterceptor 注册到拦截器链中,配置哪些路径放行
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(jwtInterceptor)
.addPathPatterns("/api/**") // 拦截所有 /api/ 开头的请求
.excludePathPatterns( // 以下路径不拦截(白名单)
"/api/user/login", // 登录不需要 token
"/api/user/register", // 注册不需要 token
"/api/article/list", // 文章列表公开
"/api/article/ranking/views", // 阅读排行公开
"/api/article/ranking/latest",// 最新发布公开
"/api/category/list", // 分类列表公开
"/api/notice/list" // 公告列表公开
);
}
拦截情况:

6. UserController.java — 登录/注册接口
登录成功后调用 JwtUtil 生成 token,和 user 一起返回给前端
@PostMapping("/login")
public Result<Map<String, Object>> login(@RequestBody User user) {
// 1. 校验用户名密码(密码用 BCrypt 比对)
User loggedInUser = userService.login(user.getUsername(), user.getPassword());
// 2. 校验通过 → 生成 JWT token
String token = JwtUtil.generateToken(loggedInUser.getId());
// 3. 返回 user + token
Map<String, Object> data = new HashMap<>();
data.put("user", loggedInUser);
data.put("token", token);
return Result.success(data);
}
登录返回token流程
① 接收前端传的 {username, password}
↓
② userService.login(username, password)
├─ 用户不存在 → 抛异常 "用户不存在"
├─ 密码错误 → 抛异常 "密码错误"
└─ 校验通过 → 返回 User 对象
↓
③ JwtUtil.generateToken(userId) → 生成 token 字符串
↓
④ 构造 Map → { user: User对象, token: "xxx" }
↓
⑤ Result.success(map) → 返回给前端
- 为什么返回 Map 而不是直接返回 User?
因为登录接口不仅要返回用户信息,还要返回 token 给前端保存。所以把
user和token放在一个 Map 里一起返回,前端收到后分别存到 store。
二.放行路径的设计原则
·原则 1:不需要登录就能访问的接口 → 放行
·原则 2:需要登录才能操作的接口 → 拦截
·原则 3:用两层放行(精确路径 + 正则绕过)
第一层(WebMvcConfig.excludePathPatterns):
→ 静态精确路径,如 /api/article/list
第二层(JwtInterceptor.preHandle 中的 GET 绕过):
→ 动态路径正则匹配,如 GET /api/article/123
→ 只在 GET 方法下生效,POST/PUT/DELETE 照常拦截
·原则 4:最小权限原则
能放行 GET 就不放行 POST,能放行精确路径就不放行通配符。比如 POST /api/site/config 需要登录,而 GET /api/site/config 公开——用两层放行实现同路径不同方法的差异化权限。
三.面试话术
面试官问:“你项目里 JWT 怎么实现的?”
"我们项目用的是自实现 JWT 认证,没有用 Spring Security 的认证框架。整体流程是这样的:
后端:有一个 JwtUtil 工具类,提供三个方法——generateToken 生成 token、validateToken 校验 token、getUserIdFromToken 从 token 解析用户 ID。toke 用 HMAC-SHA256 签名,24 小时过期。
拦截器:写了一个 JwtInterceptor 实现 HandlerInterceptor,在 preHandle 里对每个请求做三层判断——首先看路径是不是在白名单里(登录、注册、公开列表等),然后看有没有 Authorization 请求头,最后校验 token 有没有过期或篡改。
前端:登录成功后把 token 存到 localStorage,然后在封装的 request 函数里用拦截器逻辑,每次请求自动从 localStorage 读取 token 并放到 Authorization 请求头里。
总的来说就是:登录发 token → 前端存 token → 请求带 token → 后端验 token。"