基于SpringBoot+JWT 实现Token登录认证与登录人信息查询功能

<!-- JWT核心依赖：提供Token生成、解析的API -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<!-- JWT运行时依赖：实现核心API的底层逻辑 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope> <!-- 仅运行时生效，编译时不依赖 -->
</dependency>
<!-- JWT JSON序列化依赖：用于Payload中JSON数据的序列化/反序列化 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

jwt:
  secret: "zxcvbnmlkjhgfdsaqwertyuiop123456" # 自定义密钥，长度≥32位，建议生产环境使用更复杂的密钥
  expiration: 7200 # Token过期时间（秒），7200秒=2小时

package com.qcby.aischool.util;
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.security.Key;
import java.util.Date;
@Component // 交给Spring管理，支持依赖注入
public class JwtUtil {
    // 从配置文件注入Token过期时间（秒）
    @Value("${jwt.expiration}")
    private long expiration;
    // 从配置文件注入JWT密钥
    @Value("${jwt.secret}")
    private String secret;
    /**
     * 生成Token（核心方法）
     * @param id 存储在Token中的用户标识（如用户ID、用户名，本文用用户ID）
     * @return 生成的JWT Token字符串
     */
    public String generateToken(String id) {
        // 1. 根据密钥生成加密Key（HS256算法要求Key为HmacSHA256类型）
        Key key = Keys.hmacShaKeyFor(secret.getBytes());
        // 2. 构建Token并返回
        return Jwts.builder()
                .setSubject(id) // 设置Payload：存储用户标识（核心信息）
                .setIssuedAt(new Date()) // 设置签发时间（当前时间）
                // 设置过期时间：当前时间 + 过期时间（秒转毫秒）
                .setExpiration(new Date(System.currentTimeMillis() + expiration * 1000))
                .signWith(key, SignatureAlgorithm.HS256) // 设置签名算法和密钥
                .compact(); // 生成最终的Token字符串
    }
    /**
     * 解析Token，获取存储在Payload中的用户标识（如用户ID）
     * @param token 客户端传递的Token字符串
     * @return 用户标识（本文返回用户ID）
     */
    public String getUsernameFromToken(String token) {
        // 1. 生成加密Key（与生成Token时的密钥一致）
        Key key = Keys.hmacShaKeyFor(secret.getBytes());
        // 2. 解析Token，获取Payload中的subject（即用户标识）
        return Jwts.parserBuilder()
                .setSigningKey(key) // 设置验证签名的密钥
                .build() // 构建解析器
                .parseClaimsJws(token) // 解析Token（若Token无效，会抛出JwtException）
                .getBody() // 获取Payload部分
                .getSubject(); // 获取subject（用户标识）
    }
    /**
     * 验证Token是否有效（核心方法）
     * @param token 客户端传递的Token字符串
     * @return true：Token有效；false：Token无效（签名错误、已过期、格式错误等）
     */
    public boolean validateToken(String token) {
        try {
            // 1. 生成加密Key
            Key key = Keys.hmacShaKeyFor(secret.getBytes());
            // 2. 解析Token，若解析成功且未过期，则Token有效
            Jwts.parserBuilder()
                    .setSigningKey(key)
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            // 捕获异常：JwtException（Token签名错误、已过期等）、IllegalArgumentException（Token格式错误）
            return false;
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController // 标记为控制器，处理HTTP请求
public class LoginController {
    // 注入管理员服务（用于查询数据库，验证用户身份，替换为自己项目中的Service）
    @Autowired
    private AdministratorService administratorService;
    // 注入JWT工具类（用于生成Token）
    @Autowired
    private JwtUtil jwtUtil;
    /**
     * 登录接口（客户端提交用户名/密码，获取Token）
     * @param user 客户端传递的登录信息（包含用户名、密码，封装为Administrator实体类）
     * @return 响应结果（成功返回Token，失败返回错误信息）
     */
    @PostMapping("/login")
    @ResponseBody
    public Result login(@RequestBody Administrator user){
        // 1. 验证用户身份：查询数据库，判断用户名/密码是否正确（实际项目中需加密密码后比对）
        List<Administrator> users = administratorService.login(user);
        // 2. 验证通过（查询到唯一用户），生成Token
        if (users.size() == 1){
            // 获取登录用户的ID，作为Token的Payload（用户标识）
            String userId = users.get(0).getId().toString();
            // 调用JwtUtil生成Token
            String token = jwtUtil.generateToken(userId);
            // 构建响应数据，将Token返回给客户端
            Map<String,String> data = new HashMap<>();
            data.put("token", token);
            // 返回成功响应（Result为自定义响应实体，包含code、msg、data）
            return new Result().success(data);
        }else {
            // 验证失败（未查询到用户或查询到多个用户），返回错误信息
            return new Result().error("用户名或密码错误");
        }
    }
}

    /**
     * 登录人信息查询接口（需携带Token访问）
     * 前端请求路径：/api/user/info（可根据实际需求修改）
     * @param request 请求对象，用于获取拦截器解析后的用户ID
     * @return 登录人的完整信息（如管理员信息）
     */
    @GetMapping("/info")
    @ResponseBody
    public Result getLoginAdministratorInfo(HttpServletRequest request) {
        System.out.println("进入查询登录人信息的接口");
        // 1. 从request中获取拦截器解析的用户ID（拦截器已验证Token有效性）
        String id = (String) request.getAttribute("id");
        // 2. 根据用户ID查询数据库，获取登录人完整信息
        Administrator administrator = administratorService.findAdministratorById(Integer.valueOf(id));
        // 3. 返回登录人信息
        return Result.success(administrator);
    }

@Component
public class JwtInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtUtil jwtUtil;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 从Header中获取Token（前端需将Token放在Authorization中）
        String token = request.getHeader("Authorization");
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7); // 去掉"Bearer "前缀
        }
        // 2. 验证Token
        if (token == null || !jwtUtil.validateToken(token)) {
            response.setStatus(401); // 未授权
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"code\":401,\"message\":\"Token无效或已过期\"}");
            return false;
        }
        // 3. Token有效，将用户ID存入request属性中
        String userId = jwtUtil.getUsernameFromToken(token);
        request.setAttribute("id", userId);
        // 4. 继续处理请求
        return true;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private JwtInterceptor jwtInterceptor;
    // 加自定义拦截器JwtInterceptor，设置拦截规则
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/administrator/login");  
    }
}