SpringBoot基于token防止订单重复创建

package cn.hollis.nft.turbo.auth.controller;

import cn.dev33.satoken.stp.StpUtil;
import cn.hollis.nft.turbo.auth.exception.AuthErrorCode;
import cn.hollis.nft.turbo.auth.exception.AuthException;
import cn.hollis.nft.turbo.web.vo.Result;
import jakarta.validation.constraints.NotBlank;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

import static cn.hollis.nft.turbo.cache.constant.CacheConstant.CACHE_KEY_SEPARATOR;

/**
 * TokenController 类负责处理与 token 相关的请求，
 * 主要功能是在用户登录状态下生成并发放一个基于 UUID 的 token，
 * 并将其存储到 Redis 中。
 *
 * @author hollis
 */
@Slf4j
@RequiredArgsConstructor
@RestController
@RequestMapping("token")
public class TokenController {

    /**
     * 定义 token 键的前缀，用于在 Redis 中存储 token 时标识键。
     */
    private static final String TOKEN_PREFIX = "token:";

    /**
     * 注入 Spring Data Redis 提供的 StringRedisTemplate，
     * 用于操作 Redis 中的字符串类型数据。
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 该接口用于在用户登录状态下，根据传入的场景信息生成一个唯一的 token，
     * 并将其存储到 Redis 中，设置 30 分钟的过期时间。
     *
     * @param scene 生成 token 的场景信息，不能为空。
     * @return 封装了生成的 token 键的统一响应对象 Result。
     * @throws AuthException 若用户未登录，抛出用户未登录的认证异常。
     */
    @GetMapping("/get")
    public Result<String> get(@NotBlank String scene) {
        // 检查用户是否已登录
        if (StpUtil.isLogin()) {
            // 生成一个基于 UUID 的唯一 token
            String token = UUID.randomUUID().toString();
            // 拼接用于存储到 Redis 的 token 键
            String tokenKey = TOKEN_PREFIX + scene + CACHE_KEY_SEPARATOR + token;
            // 将 token 存储到 Redis 中，设置 30 分钟的过期时间
            stringRedisTemplate.opsForValue().set(tokenKey, token, 30, TimeUnit.MINUTES);
            // 返回包含 token 键的成功响应
            return Result.success(tokenKey);
        }
        // 若用户未登录，抛出用户未登录的认证异常
        throw new AuthException(AuthErrorCode.USER_NOT_LOGIN);
    }
}

package jakarta.servlet;

import java.io.IOException;

public interface Filter {
    // 过滤器初始化方法，在过滤器实例创建后调用，用于初始化资源
    public default void init(FilterConfig filterConfig) throws ServletException {}

    // 过滤方法，每次请求经过该过滤器时都会调用，用于实现具体的过滤逻辑
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException;

    // 过滤器销毁方法，在过滤器实例销毁前调用，用于释放资源
    public default void destroy() {}
}

package cn.hollis.nft.turbo.web.filter;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.BooleanUtils;
import org.redisson.api.RScript;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.Arrays;
import java.util.UUID;

/**
 * @author Hollis
 */
public class TokenFilter implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(TokenFilter.class);

    public static final ThreadLocal<String> tokenThreadLocal = new ThreadLocal<>();

    public static final ThreadLocal<Boolean> stressThreadLocal = new ThreadLocal<>();

    private RedissonClient redissonClient;

    // 选择构造器注入bean的方式 是spring官方推荐的注入方式
    public TokenFilter(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 过滤器初始化，可选实现
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        try {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            // 从请求头中获取Token
            String token = httpRequest.getHeader("Authorization");
            // 原来的逻辑是从redis里获取并且验证token
            // 如果是压测环境 那么直接生成一个UUID作为Token
            Boolean isStress = BooleanUtils.toBoolean(httpRequest.getHeader("isStress"));

            if (token == null || "null".equals(token) || "undefined".equals(token)) {
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("No Token Found ...");
                logger.error("no token found in header , pls check!");
                return;
            }
            // 校验Token的有效性
            boolean isValid = checkTokenValidity(token, isStress);
            // Token无效
            if (!isValid) {
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("Invalid or expired token");
                logger.error("token validate failed , pls check!");
                return;
            }
            // Token有效，继续执行其他过滤器链
            chain.doFilter(request, response);
        } finally {
            // ThreadLocal 可能会存在内存泄漏的问题
            tokenThreadLocal.remove();
            stressThreadLocal.remove();
        }
    }

    private boolean checkTokenValidity(String token, Boolean isStress) {
        // 获取指定键的值
        // 删除这个键
        // 返回获取到的数值
        String luaScript = """
                local value = redis.call('GET', KEYS[1])
                redis.call('DEL', KEYS[1])
                return value""";
        // 6.2.3以上可以直接使用GETDEL命令
        // String value = (String) redisTemplate.opsForValue().getAndDelete(token);
        String result = (String) redissonClient.getScript().eval(RScript.Mode.READ_WRITE,
                luaScript,
                RScript.ReturnType.STATUS,
                Arrays.asList(token));
        if (isStress) {
            //如果是压测，则生成一个随机数，模拟 token
            result = UUID.randomUUID().toString();
            stressThreadLocal.set(isStress);
        }
        tokenThreadLocal.set(result);
        return result != null;

    }

    @Override
    public void destroy() {
        // 过滤器销毁，可选实现
    }
}

package cn.hollis.nft.turbo.web.configuration;

import cn.hollis.nft.turbo.web.filter.TokenFilter;
import cn.hollis.nft.turbo.web.handler.GlobalWebExceptionHandler;
import org.redisson.api.RedissonClient;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author Hollis
 * 这是所有mvc入口的一个配置 实现了 WebMvcConfigurer接口
 * AutoConfiguration注解 标记此类为自动配置类
 * ConditionalOnWebApplication 条件注释 表示在web环境下 配置类生效
 * 注册了一系列过滤器
 */
@AutoConfiguration
@ConditionalOnWebApplication
public class WebConfiguration implements WebMvcConfigurer {

    @Bean
    @ConditionalOnMissingBean
    GlobalWebExceptionHandler globalWebExceptionHandler() {
        return new GlobalWebExceptionHandler();
    }

    /**
     * 注册token过滤器
     *
     * @param redissonClient
     * @return
     */
    @Bean
    public FilterRegistrationBean<TokenFilter> tokenFilter(RedissonClient redissonClient) {
        FilterRegistrationBean<TokenFilter> registrationBean = new FilterRegistrationBean<>();
        // 设置要注册的过滤器为 TokenFilter 实例，并传入 RedissonClient 对象。
        registrationBean.setFilter(new TokenFilter(redissonClient));
        // 设置过滤器需要拦截的 URL 路径，只有请求路径匹配这些模式时，TokenFilter 才会处理该请求。
        registrationBean.addUrlPatterns("/trade/buy","/trade/newBuy","/trade/normalBuy");
        // 设置过滤器的执行顺序，数字越小，执行优先级越高。
        registrationBean.setOrder(10);

        return registrationBean;
    }

}