安全模块

@Getter
@Setter
@ConfigurationProperties(prefix = "jwt")
public class JwtProperties {
    private String secret;
    private Integer expireTime;
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private final LoginInterceptor loginInterceptor;

    public WebConfig(LoginInterceptor loginInterceptor) {
        this.loginInterceptor = loginInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor);
        WebMvcConfigurer.super.addInterceptors(registry);
    }
}

@Configuration
@Import(WebConfig.class)
@EnableConfigurationProperties(JwtProperties.class)
public class JwtAutoConfiguration {

    @Bean
    public LoginInterceptor loginInterceptor(TokenService tokenService) {
        return new LoginInterceptor(tokenService);
    }
}

public class LoginRedisKeyPrefix extends BaseKeyPrefix {
    public static final LoginRedisKeyPrefix USER_LOGIN_INFO_STRING = new LoginRedisKeyPrefix("USER:LOGIN:INFO");

    public LoginRedisKeyPrefix(String prefix) {
        super(prefix);
    }

    public LoginRedisKeyPrefix(String prefix, Long timeout, TimeUnit unit) {
        super(prefix, timeout, unit);
    }
}

/**
 * token验证处理
 */
@Component
public class TokenService {
    public static final String TOKEN_HEADER = "Token";
    private static final String LOGIN_USER_REDIS_UUID = "uuid";
    private static final long MINUTES_MILLISECONDS = 60 * 1000L;
    private static final long TWENTY_MILLISECONDS = 20 * MINUTES_MILLISECONDS;
    private final SecretKey key;

    private final JwtProperties jwtProperties;
    private final RedisService redisService;

    public TokenService(JwtProperties jwtProperties, RedisService redisService) {
        this.jwtProperties = jwtProperties;
        this.redisService = redisService;
        this.key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(jwtProperties.getSecret()));
    }

    /**
     * 创建 Token
     * @param loginUser 用户信息
     * @return token
     */
    public String createToken(LoginUser loginUser) {
        // 设置登陆时间和过期时间
        long now = System.currentTimeMillis();
        loginUser.setLoginTime(now);
        long expireTime = now + jwtProperties.getExpireTime() * MINUTES_MILLISECONDS;
        loginUser.setExpireTime(expireTime);

        // 生成UUID
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        loginUser.setToken(uuid);

        // 将用户信息缓存到Redis中, 设置过期时间
        String redisKey = UserRedisKeyPrefix.USER_LOGIN_INFO_STRING.fullKey(uuid);
        redisService.setCacheObject(redisKey, loginUser, expireTime, TimeUnit.MICROSECONDS);

        // 4. 使用JWT生成TOKEN，存入基础信息
        return Jwts.builder()
                .id(loginUser.getId().toString())
                .claim(LOGIN_USER_REDIS_UUID, uuid)
                .signWith(key).compact();
    }

    /**
     * 获取用户身份信息
     *
     * @return 用户信息
     */
    public LoginUser getLoginUser(String token) {
        // 判断 Token 是否有效
        SecretKey key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(jwtProperties.getSecret()));
        Claims body = Jwts.parser().verifyWith(key).build().parseSignedClaims(token).getPayload();
        String uuid = (String) body.get(LOGIN_USER_REDIS_UUID);

        // 从Redis中获取用户对象
        String redisKey = UserRedisKeyPrefix.USER_LOGIN_INFO_STRING.fullKey(uuid);
        return redisService.getCacheObject(redisKey);
    }

    /**
     * 刷新令牌有效期
     *
     * @param loginUser 登录信息
     */
    public void refreshToken(LoginUser loginUser) {
        long loginTime;
        if ((loginUser.getExpireTime() - (loginTime = System.currentTimeMillis())) <= TWENTY_MILLISECONDS) {
            // 如果用户过期剩余时间小于20分钟，刷新过期时间
            loginUser.setLoginTime(loginTime);
            long expireTime = loginTime + jwtProperties.getExpireTime() * MINUTES_MILLISECONDS;
            loginUser.setExpireTime(expireTime);
            // 将刷新后的时间覆盖Redis
            String redisKey = UserRedisKeyPrefix.USER_LOGIN_INFO_STRING.fullKey(loginUser.getToken());
            redisService.setCacheObject(redisKey, loginUser, expireTime, TimeUnit.MICROSECONDS);
        }
    }

    public static void main(String[] args) {
        Key key = Jwts.SIG.HS256.key().build();
        String secretString = Encoders.BASE64.encode(key.getEncoded());
        System.out.println(secretString);
    }
}

public class AuthenticationUtil {
    private static final ThreadLocal<LoginUser> USER_HOLDER = new ThreadLocal<>();

    public static HttpServletRequest getRequest() {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (requestAttributes == null) {
            throw new BizException("该方法只能在Spring MVC 环境下调用");
        }
        return requestAttributes.getRequest();
    }

    public static String getToken() {
        return getRequest().getHeader(TokenService.TOKEN_HEADER);
    }

    /**
     * 从Token或者缓存中获取User
     * @return 登陆用户
     */
    public static LoginUser getLoginUser() {
        LoginUser cacheUser = USER_HOLDER.get();
        if (cacheUser != null) {
            return cacheUser;
        }
        String token = getToken();
        if (StringUtils.isEmpty(token) || token.equals("undefined")) {
            return null;
        }
        TokenService tokenService = SpringContextUtil.getBean(TokenService.class);
        LoginUser loginUser = tokenService.getLoginUser(token);
        USER_HOLDER.set(loginUser);
        return loginUser;
    }

    /**
     * 清空缓存中的User
     */
    public static void removeUser() {
        USER_HOLDER.remove();
    }
}

/**
 * Spring工具类,获取Spring上下文对象等
 *
 * @author swcode
 * @since 2023/10/26 13:31
 */
@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;

    /**
     * 1. SpringContextUtil 被 JVM 加载时, applicationContext 作为静态属性, 就被初始化了, 但是此时是 null 值
     * 2. 当 Spring 容器初始化以后, 会管理 SpringContextUtil Bean 对象
     * 3. 当 Spring 创建 SpringContextUtil 实例对象时,
     * 在初始化阶段会自动调用实现了 ApplicationContextAware 的 setApplicationContext 方法,
     * 此时该类中原本静态容器属性就从 null 变成了容器对象
     * 4. 当容器启动成功后, 其他业务代码通过该类的静态成员, 就可以直接的访问容器对象, 从容器对象中获取其他 Bean 对象
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringContextUtil.applicationContext == null) {
            SpringContextUtil.applicationContext = applicationContext;
            System.out.println("----------" + applicationContext);
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

@Slf4j
@Component
public class LoginInterceptor implements HandlerInterceptor {

    private final TokenService tokenService;

    public LoginInterceptor(TokenService tokenService) {
        this.tokenService = tokenService;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            // handler => 静态资源
            // handler => CORS 的预请求
            return true;
        }
        // 将 handler 对象转换为 HandlerMethod 对象
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        // 从 HandlerMethod 对象中获取对应的 Controller 对象
        Class<?> clazz = handlerMethod.getBeanType();
        Method method = handlerMethod.getMethod();
        // 从 Controller 和 HandlerMethod 上获取 @RequireLogin 注解
        if (clazz.isAnnotationPresent(RequireLogin.class) || method.isAnnotationPresent(RequireLogin.class)) {
            // 1. 从请求头中获取 jwt token
            String token = request.getHeader(TokenService.TOKEN_HEADER);
            // 2. 基于 jwt sdk 解析 token，解析失败
            try {
                LoginUser loginUser = tokenService.getLoginUser(token);
                if (loginUser == null) {
                    throw new BizException(401, "Token 已失效");
                }
                // 未失效，刷新Token
                tokenService.refreshToken(loginUser);
            } catch (BizException e) {
                throw e;
            } catch (Exception e) {
                log.warn("[登陆拦截] jwt token 解析失败");
                throw new BizException(401, "用户未认证");
            }
        }
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 请求执行完成之后，准备响应之前
        // 线程即将完成本次请求，将当前线程存储的数据清楚
        AuthenticationUtil.removeUser();
    }
}