import java.util.Date; import java.util.HashMap; import java.util.Map;

/**

• @description: JWT 工具类 **/ @Slf4j public class JWTUtil {

  /**

  • 过期时间 / private static final long EXPIRATION = 86400L; /*
  • Token 前缀 / public static final String TOKEN_PREFIX = “Bearer ”; /*
  • 签发者 / public static final String ISS = “songbaicheng”; /*
  • 密钥 */ public static final String SECRET = “SecretKey039245678901232039487623456783092349288901402967890140939827”;

  /**

  • 生成用户 Token
  • @param userInfo 用户信息
  • @return 用户访问 Token */ public static String generateAccessToken(UserInfoDTO userInfo) { Map<String, Object> claims = generateClaims(userInfo); return TOKEN_PREFIX + generateToken(claims); }

  /**

  • 验证用户 Token 的有效性
  • @param jwtToken 用户访问 Token
  • @return 是否有效 */ public static boolean validateToken(String jwtToken) { if (StringUtils.hasText(jwtToken)) { String actualJwtToken = jwtToken.replace(TOKEN_PREFIX, ""); try { Claims claims = Jwts.parser().setSigningKey(SECRET).parseClaimsJws(actualJwtToken).getBody(); return validateTokenExpiration(claims); } catch (ExpiredJwtException ignored) { log.warn(“JWT Token 已过期”); } catch (Exception ex) { log.error(“JWT Token 解析失败！”, ex); } } return false; }

  /**

  • 解析用户 Token
  • @param jwtToken 用户访问 Token
  • @return 用户信息 */ public static UserInfoDTO parseJwtToken(String jwtToken) { if (StringUtils.hasText(jwtToken)) { String actualJwtToken = jwtToken.replace(TOKEN_PREFIX, ""); try { Claims claims = Jwts.parser().setSigningKey(SECRET).parseClaimsJws(actualJwtToken).getBody(); if (validateTokenExpiration(claims)) { return retrieveUserInfoFromClaims(claims); } } catch (ExpiredJwtException ignored) { } catch (Exception ex) { log.error(“JWT Token 解析失败！”, ex); throw new ServiceException(“JWT Token 解析失败！”); } } return null; }

  private static Map<String, Object> generateClaims(UserInfoDTO userInfo) { Map<String, Object> claims = new HashMap<>(); claims.put(“userId”, userInfo.getUserId()); claims.put(“username”, userInfo.getUsername()); claims.put(“realName”, userInfo.getRealName()); return claims; }

  private static String generateToken(Map<String, Object> claims) { return Jwts.builder() .setClaims(claims) .setIssuedAt(new Date()) .setIssuer(ISS) .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION * 1000)) .signWith(SignatureAlgorithm.HS512, SECRET) .compact(); }

  private static boolean validateTokenExpiration(Claims claims) { Date expiration = claims.getExpiration(); return expiration != null && expiration.after(new Date()); }

  private static UserInfoDTO retrieveUserInfoFromClaims(Claims claims) { String subject = claims.getSubject(); return JSON.parseObject(subject, UserInfoDTO.class); } }

<details>
<summary>### 校验 Token 过滤器</summary>
我们这里并不搭配 Spring Security 等权限框架，我们只需要校验请求头中携带的 Token 是否有效即可，这里有两种实现方式，分别是 AOP 和 Filter 过滤器，我们分别说一下这两种方式的优缺点。

- AOP (面向切面编程)：
  - 优点：
    1. 解耦性好：AOP 能够将横切关注点（如权限校验、日志记录等）从业务逻辑中分离出来，使代码更加清晰和模块化。
    2. 灵活性高：可以灵活地指定切入点（如指定特定方法或类），只在需要的地方执行拦截逻辑。
    3. 可读性强：通过注解的方式定义切面，使得代码意图更为明确，便于阅读和维护。
  - 缺点：
    1. 性能开销：虽然现代框架已经尽可能减少了 AOP 的性能影响，但在某些高并发场景下，动态代理可能会带来轻微的性能开销。
    2. 作用域限制：AOP主要针对业务逻辑层（如 Service 层），对于进入 Web 容器之前的请求处理（如静态资源、错误页面等）控制能力有限。
- Filter (过滤器)
  - 优点：
    1. 全面覆盖：Filter 可以拦截所有进出Web容器的请求和响应，包括静态资源、错误页面等，控制层面更广。
    2. 简单易用：相比 AOP，Filter 的配置和实现较为直观，容易上手，符合 Servlet 规范，不依赖特定框架。
    3. 性能高效：作为 Servlet 规范的一部分，Filter 在设计上就考虑了性能问题，对于纯请求过滤处理，性能损耗较低。
  - 缺点：
    1. 侵入性：Filter 需要在 Web.xml 或使用注解进行配置，对 Web 应用的结构有一定的侵入。
    2. 逻辑分散：随着应用复杂度增加，如果过多地使用Filter，可能会导致过滤逻辑分散在多个 Filter 中，不易管理和维护。
    3. 粒度较粗：Filter 通常针对整个请求/响应链路，难以精确到方法级别，不如 AOP 灵活。

根据以上的分析，结合现在大多数都高并发场景的情况，我们更推荐性能更优的 Filter 方式，虽然力度上不如 AOP 加校验注解的方式更灵活，可大部分项目的设计初衷都是除登录等白名单接口外，其余所有接口都应该进行校验。话不多说我们直接开始创建和注入过滤器。

<details>
<summary>JWT 认证过滤器创建</summary>
```java
import com.sbc.auth.toolkit.JWTUtil;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.util.StringUtils;

import java.io.IOException;

/**
 * @description: JWT 认证过滤器
 **/
public class JwtAuthenticationFilter implements Filter {

    @Override
    public void init(jakarta.servlet.FilterConfig filterConfig) throws ServletException {
        jakarta.servlet.Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        // 设置响应字符编码为 UTF-8
        httpResponse.setCharacterEncoding("UTF-8");

        String requestURI = httpRequest.getRequestURI();
        if (!requestURI.endsWith("/login")) {
            // 获取请求头 Token
            String token = getJwtFromRequest(httpRequest);
            if (token == null) {
                // 如果没有携带 Token，返回 401 错误
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("未携带 Token");
                return;
            }
            // 如果 Token 无效，也返回 401 错误
            if (!JWTUtil.validateToken(token)) {
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("Token 已失效，请重新登录获取新 Token");
                return;
            }
        }

        chain.doFilter(request, response);
    }


    /**
     * 获取请求头 Token 凭证
     *
     * @param request 请求信息
     * @return Token 令牌
     */
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

<details>
<summary>### 生成令牌和携带令牌</summary>
正如我们过滤器中的规则，除了请求路径结尾为 ```/login``` 并且匹配  ```/api/*``` 的请求都会在请求头中校验 ```Authorization``` 字段携带的 Token，我们的前端请求使用 Axios 配置如下：

<details>
<summary>Axios 配置</summary>
```typescript
import { ElMessage } from 'element-plus'
import axios from 'axios'
import type { AxiosError, AxiosInstance, AxiosResponse } from 'axios'
import { useAuthStore } from '@/stores/authStore'

const axiosInstance: AxiosInstance = axios.create({
  timeout: 10000, // 设置请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
axiosInstance.interceptors.request.use(
  (config) => {

    // 为确保 pinia 实例被激活，最简单的方法就是将 useStore() 的调用放在 pinia 安装后才会执行的函数中。
    // https://pinia.vuejs.org/zh/core-concepts/outside-component-usage.html
    const authStore = useAuthStore()

    const token: string | null = authStore.authState.token
    if (token) {
      config.headers.Authorization = `${token}`
    }
    return config
  },
  (error: AxiosError) => {
    // 对请求错误做些什么
    return Promise.reject(error)
  }
)

// 响应拦截器
axiosInstance.interceptors.response.use(
  (response: AxiosResponse) => {
    // 在这里可以对响应进行处理
    if (response.status === 401) {
      ElMessage.error('用户未登录或已过期！')
      window.location.href = 'login'
    }
    return response
  },
  (error: AxiosError) => {
    // 对响应错误做些什么
    console.log(error, 'error')
    if (error.response && error.response.status === 401) {
      ElMessage.error('用户未登录或已过期！')
      window.location.href = 'login'
    }
    return Promise.reject(error)
  }
)

export default axiosInstance