电商实践基于token防止订单重复创建

最新推荐文章于 2025-09-01 23:51:35 发布

程序员多多_

最新推荐文章于 2025-09-01 23:51:35 发布

阅读量575

点赞数 20

CC 4.0 BY-SA版权

分类专栏： web后端开发 # SpringBoot # 高并发秒杀电商平台文章标签： bootstrap 前端 html java jvm 数据库 spring

本文链接：https://blog.csdn.net/qq_30500575/article/details/148461433

web后端开发同时被 3 个专栏收录

187 篇文章

订阅专栏

SpringBoot

70 篇文章

订阅专栏

高并发秒杀电商平台

10 篇文章

订阅专栏

接着是在 Spring MVC 处入口配置

业务场景是这样的

我们在秒杀场景中通常是疯狂点击下单

但是最后是只会创建一个订单

点击一个下单按钮是发一次请求

如何保证一个用户一次点击只创建一个订单呢

首先在此之前我们需要对用户的权限进行校验

我们这边使用的token实现

签发token

每次进入下单界面会签发一个token给浏览器顺便写入redis

然后在下单的时候客户端只要带这个token过来

然后顺便服务端校验就行

这个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);
    }
}

我们将这个token返回个前端

调用下单接口是把这个token带来

然后去redis里看一下是不是有效就行

有效放过去

无效的话就返回

执行其他校验链

首先基于 Filter 写过滤器

在请求过来后首先到达的是过滤器然后才是servlet

Filter 是一个servlet组件

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() {
        // 过滤器销毁，可选实现
    }
}

注入的是 redissonClient 即redis的客户端

同样我们要指定log 用于打印日志

还维护一个ThreadLocal 首先是保证线程安全其次是在组装订单字段的时候把token放进去做一个幂等校验

请求进来后就到了这边

首先通过 mvc提供的 httpRequest从请求头里面取出token
取出来后我们进行校验

调用checkTokenValidity方法进行校验

用LUA脚本去redis里拿这个token 移除保证原子性

如果成功了最后放到ThreadLocal后继续执行其他校验链

疑问为什么要基于Filter写过滤器

使用过滤器能将 Token 校验逻辑集中管理，避免在每个需要校验 Token 的业务方法里重复编写校验代码。例如，若有多个接口都需要进行 Token 校验，只需配置过滤器拦截这些接口，就能统一进行校验，而不用在每个接口方法中重复写校验逻辑。

接着是在 Spring MVC 处入口配置

只有先配置了过滤器才能生效

我们是在这里添加token的校验 URL配置等

可以理解成注册 filter 过滤器

"注册" 在这段代码中有两层含义：

一. 是把对象注册到 Spring 容器进行管理；

二. 是将 Servlet 过滤器注册到 Servlet 容器，使其能在请求处理流程中发挥作用。

通过 FilterRegistrationBean，将 TokenFilter 过滤器注册到 Servlet 容器中，Servlet 容器会在处理请求时，按照配置的规则调用 TokenFilter 进行过滤操作。

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;
    }

}