经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring Boot » 查看文章
如何防止用户重复提交订单？（下）
来源：cnblogs　　作者：程序员志哥　　时间：2022/11/23 18:51:27　　对本文有异议

一、摘要

在上一篇文章中，我们详细的介绍了随着下单流量逐渐上升，为了降低数据库的访问压力，通过请求唯一ID+redis分布式锁来防止接口重复提交，流程图如下！

每次提交的时候，需要先调用后端服务获取请求唯一ID，然后才能提交。

对于这样的流程，不少的同学可能会感觉到非常鸡肋，尤其是单元测试，需要每次先获取submitToken值，然后才能提交！

能不能不用这么麻烦，直接服务端通过一些规则组合，生成本次请求唯一ID呢？

答案是可以的！

今天我们就一起来看看，如何通过服务端来完成请求唯一 ID 的生成？

二、方案实践

我们先来看一张图，这张图就是本次方案的核心流程图。

实现的逻辑，流程如下：

  • 1.用户点击提交按钮，服务端接受到请求后，通过规则计算出本次请求唯一ID值
  • 2.使用redis的分布式锁服务，对请求 ID 在限定的时间内尝试进行加锁，如果加锁成功，继续后续流程；如果加锁失败，说明服务正在处理，请勿重复提交
  • 3.最后一步，如果加锁成功后，需要将锁手动释放掉，以免再次请求时，提示同样的信息

引入缓存服务后，防止重复提交的大体思路如上，实践代码如下！

2.1、引入 redis 组件

本次 demo 项目是基于SpringBoot版本进行构建，添加相关的redis依赖环境如下：

  1. <!-- 引入springboot -->
  2. <parent>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-parent</artifactId>
  5.     <version>2.1.0.RELEASE</version>
  6. </parent>
  8. ......
  10. <!-- Redis相关依赖包，采用jedis作为客户端 -->
  11. <dependency>
  12.     <groupId>org.springframework.boot</groupId>
  13.     <artifactId>spring-boot-starter-data-redis</artifactId>
  14.     <exclusions>
  15.         <exclusion>
  16.             <groupId>redis.clients</groupId>
  17.             <artifactId>jedis</artifactId>
  18.         </exclusion>
  19.         <exclusion>
  20.             <artifactId>lettuce-core</artifactId>
  21.             <groupId>io.lettuce</groupId>
  22.         </exclusion>
  23.     </exclusions>
  24. </dependency>
  25. <dependency>
  26.     <groupId>redis.clients</groupId>
  27.     <artifactId>jedis</artifactId>
  28. </dependency>
  29. <dependency>
  30.     <groupId>org.apache.commons</groupId>
  31.     <artifactId>commons-pool2</artifactId>
  32. </dependency>

2.2、添加 redis 环境配置

在全局配置application.properties文件中，添加redis相关服务配置如下

  1. # 项目名
  2. spring.application.name=springboot-example-submit
  4. # Redis数据库索引（默认为0）
  5. spring.redis.database=1
  6. # Redis服务器地址
  7. spring.redis.host=127.0.0.1
  8. # Redis服务器连接端口
  9. spring.redis.port=6379
  10. # Redis服务器连接密码（默认为空）
  11. spring.redis.password=
  12. # Redis服务器连接超时配置
  13. spring.redis.timeout=1000
  15. # 连接池配置
  16. spring.redis.jedis.pool.max-active=8
  17. spring.redis.jedis.pool.max-wait=1000
  18. spring.redis.jedis.pool.max-idle=8
  19. spring.redis.jedis.pool.min-idle=0
  20. spring.redis.jedis.pool.time-between-eviction-runs=100

2.3、编写服务验证逻辑，通过 aop 代理方式实现

首先创建一个@SubmitLimit注解，通过这个注解来进行方法代理拦截！

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({ElementType.METHOD})
  3. @Documented
  4. public @interface SubmitLimit {
  6.     /**
  7.      * 指定时间内不可重复提交（仅相对上一次发起请求时间差）,单位毫秒
  8.      * @return
  9.      */
  10.     int waitTime() default 1000;
  12.     /**
  13.      * 指定请求头部key，可以组合生成签名
  14.      * @return
  15.      */
  16.     String[] customerHeaders() default {};
  19.     /**
  20.      * 自定义重复提交提示语
  21.      * @return
  22.      */
  23.     String customerTipMsg() default "";
  24. }

编写方法代理服务，增加防止重复提交的验证，实现了逻辑如下！

  1. @Order(1)
  2. @Aspect
  3. @Component
  4. public class SubmitLimitAspect {
  6.     private static final Logger LOGGER = LoggerFactory.getLogger(SubmitLimitAspect.class);
  8.     /**
  9.      * redis分割符
  10.      */
  11.     private static final String REDIS_SEPARATOR = ":";
  13.     /**
  14.      * 默认锁对应的值
  15.      */
  16.     private static final String DEFAULT_LOCK_VALUE = "DEFAULT_SUBMIT_LOCK_VALUE";
  18.     /**
  19.      * 默认重复提交提示语
  20.      */
  21.     private static final String DEFAULT_TIP_MSG = "服务正在处理，请勿重复提交！";
  24.     @Value("${spring.application.name}")
  25.     private String applicationName;
  27.     @Autowired
  28.     private RedisLockService redisLockService;
  31.     /**
  32.      * 方法调用环绕拦截
  33.      */
  34.     @Around(value = "@annotation(com.example.submittoken.config.annotation.SubmitLimit)")
  35.     public Object doAround(ProceedingJoinPoint joinPoint){
  36.         HttpServletRequest request = getHttpServletRequest();
  37.         if(Objects.isNull(request)){
  38.             return ResResult.getSysError("请求参数不能为空！");
  39.         }
  40.         //获取注解配置的参数
  41.         SubmitLimit submitLimit = getSubmitLimit(joinPoint);
  42.         //组合生成key，通过key实现加锁和解锁
  43.         String lockKey = buildSubmitLimitKey(joinPoint, request, submitLimit.customerHeaders());
  44.         //尝试在指定的时间内加锁
  45.         boolean lock = redisLockService.tryLock(lockKey, DEFAULT_LOCK_VALUE, Duration.ofMillis(submitLimit.waitTime()));
  46.         if(!lock){
  47.             String tipMsg = StringUtils.isEmpty(submitLimit.customerTipMsg()) ? DEFAULT_TIP_MSG : submitLimit.customerTipMsg();
  48.             return ResResult.getSysError(tipMsg);
  49.         }
  50.         try {
  51.             //继续执行后续流程
  52.             return execute(joinPoint);
  53.         } finally {
  54.             //执行完毕之后，手动将锁释放
  55.             redisLockService.releaseLock(lockKey, DEFAULT_LOCK_VALUE);
  56.         }
  57.     }
  59.     /**
  60.      * 执行任务
  61.      * @param joinPoint
  62.      * @return
  63.      */
  64.     private Object execute(ProceedingJoinPoint joinPoint){
  65.         try {
  66.             return joinPoint.proceed();
  67.         } catch (CommonException e) {
  68.             return ResResult.getSysError(e.getMessage());
  69.         } catch (Throwable e) {
  70.             LOGGER.error("业务处理发生异常，错误信息：",e);
  71.             return ResResult.getSysError(ResResultEnum.DEFAULT_ERROR_MESSAGE);
  72.         }
  73.     }
  76.     /**
  77.      * 获取请求对象
  78.      * @return
  79.      */
  80.     private HttpServletRequest getHttpServletRequest(){
  81.         RequestAttributes ra = RequestContextHolder.getRequestAttributes();
  82.         ServletRequestAttributes sra = (ServletRequestAttributes)ra;
  83.         HttpServletRequest request = sra.getRequest();
  84.         return request;
  85.     }
  87.     /**
  88.      * 获取注解值
  89.      * @param joinPoint
  90.      * @return
  91.      */
  92.     private SubmitLimit getSubmitLimit(JoinPoint joinPoint){
  93.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  94.         Method method = methodSignature.getMethod();
  95.         SubmitLimit submitLimit = method.getAnnotation(SubmitLimit.class);
  96.         return submitLimit;
  97.     }
  99.     /**
  100.      * 组合生成lockKey
  101.      * 生成规则：项目名+接口名+方法名+请求参数签名（对请求头部参数+请求body参数，取SHA1值）
  102.      * @param joinPoint
  103.      * @param request
  104.      * @param customerHeaders
  105.      * @return
  106.      */
  107.     private String buildSubmitLimitKey(JoinPoint joinPoint, HttpServletRequest request, String[] customerHeaders){
  108.         //请求参数=请求头部+请求body
  109.         String requestHeader = getRequestHeader(request, customerHeaders);
  110.         String requestBody = getRequestBody(joinPoint.getArgs());
  111.         String requestParamSign = DigestUtils.sha1Hex(requestHeader + requestBody);
  112.         String submitLimitKey = new StringBuilder()
  113.                 .append(applicationName)
  114.                 .append(REDIS_SEPARATOR)
  115.                 .append(joinPoint.getSignature().getDeclaringType().getSimpleName())
  116.                 .append(REDIS_SEPARATOR)
  117.                 .append(joinPoint.getSignature().getName())
  118.                 .append(REDIS_SEPARATOR)
  119.                 .append(requestParamSign)
  120.                 .toString();
  121.         return submitLimitKey;
  122.     }
  125.     /**
  126.      * 获取指定请求头部参数
  127.      * @param request
  128.      * @param customerHeaders
  129.      * @return
  130.      */
  131.     private String getRequestHeader(HttpServletRequest request, String[] customerHeaders){
  132.         if (Objects.isNull(customerHeaders)) {
  133.             return "";
  134.         }
  135.         StringBuilder sb = new StringBuilder();
  136.         for (String headerKey : customerHeaders) {
  137.             sb.append(request.getHeader(headerKey));
  138.         }
  139.         return sb.toString();
  140.     }
  143.     /**
  144.      * 获取请求body参数
  145.      * @param args
  146.      * @return
  147.      */
  148.     private String getRequestBody(Object[] args){
  149.         if (Objects.isNull(args)) {
  150.             return "";
  151.         }
  152.         StringBuilder sb = new StringBuilder();
  153.         for (Object arg : args) {
  154.             if (arg instanceof HttpServletRequest
  155.                     || arg instanceof HttpServletResponse
  156.                     || arg instanceof MultipartFile
  157.                     || arg instanceof BindResult
  158.                     || arg instanceof MultipartFile[]
  159.                     || arg instanceof ModelMap
  160.                     || arg instanceof Model
  161.                     || arg instanceof ExtendedServletRequestDataBinder
  162.                     || arg instanceof byte[]) {
  163.                 continue;
  164.             }
  165.             sb.append(JacksonUtils.toJson(arg));
  166.         }
  167.         return sb.toString();
  168.     }
  169. }

部分校验逻辑用到了redis分布式锁，具体实现逻辑如下：

  1. /**
  2.  * redis分布式锁服务类
  3.  * 采用LUA脚本实现，保证加锁、解锁操作原子性
  4.  *
  5.  */
  6. @Component
  7. public class RedisLockService {
  9.     /**
  10.      * 分布式锁过期时间，单位秒
  11.      */
  12.     private static final Long DEFAULT_LOCK_EXPIRE_TIME = 60L;
  14.     @Autowired
  15.     private StringRedisTemplate stringRedisTemplate;
  17.     /**
  18.      * 尝试在指定时间内加锁
  19.      * @param key
  20.      * @param value
  21.      * @param timeout 锁等待时间
  22.      * @return
  23.      */
  24.     public boolean tryLock(String key,String value, Duration timeout){
  25.         long waitMills = timeout.toMillis();
  26.         long currentTimeMillis = System.currentTimeMillis();
  27.         do {
  28.             boolean lock = lock(key, value, DEFAULT_LOCK_EXPIRE_TIME);
  29.             if (lock) {
  30.                 return true;
  31.             }
  32.             try {
  33.                 Thread.sleep(1L);
  34.             } catch (InterruptedException e) {
  35.                 Thread.interrupted();
  36.             }
  37.         } while (System.currentTimeMillis() < currentTimeMillis + waitMills);
  38.         return false;
  39.     }
  41.     /**
  42.      * 直接加锁
  43.      * @param key
  44.      * @param value
  45.      * @param expire
  46.      * @return
  47.      */
  48.     public boolean lock(String key,String value, Long expire){
  49.         String luaScript = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('expire', KEYS[1], ARGV[2]) else return 0 end";
  50.         RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
  51.         Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key), value, String.valueOf(expire));
  52.         return result.equals(Long.valueOf(1));
  53.     }
  56.     /**
  57.      * 释放锁
  58.      * @param key
  59.      * @param value
  60.      * @return
  61.      */
  62.     public boolean releaseLock(String key,String value){
  63.         String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
  64.         RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
  65.         Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key),value);
  66.         return result.equals(Long.valueOf(1));
  67.     }
  68. }

部分代码使用到了序列化相关类JacksonUtils，源码如下：

  1. public class JacksonUtils {
  3.     private static final Logger LOGGER = LoggerFactory.getLogger(JacksonUtils.class);
  6.     private static final ObjectMapper objectMapper = new ObjectMapper();
  8.     static {
  9.         // 对象的所有字段全部列入
  10.         objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
  11.         // 忽略未知的字段
  12.         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  13.         // 读取不认识的枚举时，当null值处理
  14.         objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
  15. //        序列化忽略未知属性
  16.         objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
  17.         //忽略字段大小写
  18.         objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
  20.         objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
  21.         SimpleModule module = new SimpleModule();
  22.         module.addSerializer(Long.class, ToStringSerializer.instance);
  23.         module.addSerializer(Long.TYPE, ToStringSerializer.instance);
  24.         objectMapper.registerModule(module);
  25.     }
  27.     public static String toJson(Object object) {
  28.         if (object == null) {
  29.             return null;
  30.         }
  31.         try {
  32.             return objectMapper.writeValueAsString(object);
  33.         } catch (Exception e) {
  34.             LOGGER.error("序列化失败",e);
  35.         }
  36.         return null;
  37.     }
  39.     public static <T> T fromJson(String json, Class<T> classOfT) {
  40.         if (json == null) {
  41.             return null;
  42.         }
  43.         try {
  44.             return objectMapper.readValue(json, classOfT);
  45.         } catch (Exception e) {
  46.             LOGGER.error("反序列化失败",e);
  47.         }
  48.         return null;
  49.     }
  51.     public static <T> T fromJson(String json, Type typeOfT) {
  52.         if (json == null) {
  53.             return null;
  54.         }
  55.         try {
  56.             return objectMapper.readValue(json, objectMapper.constructType(typeOfT));
  57.         } catch (Exception e) {
  58.             LOGGER.error("反序列化失败",e);
  59.         }
  60.         return null;
  61.     }
  62. }

2.4、在相关的业务接口上，增加SubmitLimit注解即可

  1. @RestController
  2. @RequestMapping("order")
  3. public class OrderController {
  5.     @Autowired
  6.     private OrderService orderService;
  8.     /**
  9.      * 下单，指定请求头部参与请求唯一值计算
  10.      * @param request
  11.      * @return
  12.      */
  13.     @SubmitLimit(customerHeaders = {"appId", "token"}, customerTipMsg = "正在加紧为您处理，请勿重复下单！")
  14.     @PostMapping(value = "confirm")
  15.     public ResResult confirmOrder(@RequestBody OrderConfirmRequest request){
  16.         //调用订单下单相关逻辑
  17.         orderService.confirm(request);
  18.         return ResResult.getSuccess();
  19.     }
  20. }

其中最关键的一个步就是将唯一请求 ID 的生成，放在服务端通过组合来实现，在保证防止接口重复提交的效果同时，也可以显著的降低接口测试复杂度！

三、小结

本次方案相比于上一个方案，最大的改进点在于：将接口请求唯一 ID 的生成逻辑，放在服务端通过规则组合来实现，不需要前端提交接口的时候强制带上这个参数，在满足防止接口重复提交的要求同时，又能减少前端和测试提交接口的复杂度！

需要特别注意的是：使用redis的分布式锁，推荐单机环境，如果redis是集群环境，可能会导致锁短暂无效！

原文链接：https://www.cnblogs.com/dxflqm/p/16914670.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring Boot热门文章

  • 史上最详 Thymeleaf 使用教程
  • Spring Boot如何通过java -jar启动
  • Spring Boot 2.x（六）：优雅的统一返回值
  • Springboot使用Logback实现日志配置与异常记录
  • 使用SpringBoot+EasyExcel+Vue实现excel表格的导入和导出详解
  • spring boot上传文件超出大小异常无法捕获问题
  • paging组件的用法和意义
  • springboot2.0集成rabbitmq的示例代码
  • Spring MVC学习step1——框架熟悉
  • spring boot ${}占位符不起作用的解决方案

    • Spring Boot推荐文章

  • 3分钟带你搞定Spring Boot中Schedule
  • 不单独部署注册中心，又要具备注册中心的功能，我能上天！
  • 从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
  • 不单独部署注册中心，又要具备注册中心的功能，咋不让我上天？
  • EasyExcel 无法读取图片？用poi写了一个工具类
  • 【进阶篇】使用 Stream 流对比两个集合的常用操作分享
  • 关于DDD和COLA的一些总结和思考
  • SnakeYaml反序列化分析
  • RestTemplate进行https请求时适配信任证书
  • Kryo反序列化链分析

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号