• 自定义注解+AOP解决重复提交的问题

    1.哪些因素会引起重复提交？

    1. 前端下单按钮重复点击导致订单创建多次

    2. 网速等原因造成页面卡顿，用户重复刷新提交请求

    3. 黑客或恶意用户使用postman等http工具重复恶意提交表单

    2.重复提交会带来哪些问题？

    1. 会导致表单重复提交，造成数据重复或者错乱

    2. 核心接口的请求增加，会消耗服务器负载，严重甚至会造成服务器宕机

    3.订单的防重复提交你能想到几种方案？

    方式一：前端JS控制点击次数，屏蔽点击按钮无法点击

    前端可以被绕过，前端有限制，后端也需要有限制

    方式二：数据库或者其他存储增加唯一索引约束

    需要想出满足业务需求的唯一索引约束，比如注册的手机号唯一。但是有些业务是没有唯一性限制的,且重复提交也会导致数据错乱，比如你在电商平台可以买一部手机，也可以买两部手机

    方式三：服务端token令牌方式下单前先获取令牌-存储redis，下单时一并把token提交并检验和删除-lua脚本

    分布式情况下，采用Lua脚本进行操作(保障原子性)

    其中方式三 是大家采用得最多的，那有没更加优雅的方式呢？

    假如系统中不止一个地方，需要用到这种防重复提交，每一次都要写这种lua脚本，代码耦合性太强，这种又不属于业务逻辑，所以不推荐耦合进service中，可读性较低。

    4.自定义注解+AOP

    4.1 AOP+自定义注解接口防重提交多场景设计

    防重提交方式

    • token令牌方式

    • ip+类+方法方式(方法参数)

    利用AOP来实现

    • Aspect Oriented Program 面向切面编程， 在不改变原有逻辑上增加额外的功能

    • AOP思想把功能分两个部分，分离系统中的各种关注点

    优点

    • 减少代码侵入，解耦

    • 可以统一处理横切逻辑，方便添加和删除横切逻辑

    4.2 流程

    5.代码实现

    依赖

    1.       
    2.         <dependency>
    3.             <groupId>org.springframework.bootgroupId>
    4.             <artifactId>spring-boot-starter-data-redisartifactId>
    5.         dependency>
    6. ​
    7.         
    8.         <dependency>
    9.             <groupId>redis.clientsgroupId>
    10.             <artifactId>jedisartifactId>
    11.             <version>4.2.2version>
    12.         dependency>

    配置

    1. server:
    2.   port: 9004
    3. spring:
    4.   redis:
    5.     database: 0
    6.     host: localhost      # redis服务器地址
    7.     port: 6379           # redis端口
    8.     password:
    9.     jedis:
    10.       pool:
    11.         max-active: 50   # 连接池最大连接数(使用负值表示没有限制)
    12.         min-idle: 0      # 连接池中最小空闲连接
    13.         max-wait: -1ms   # 连接池最大阻塞等待时间(使用负值表示没有限制)，因为配置了timeout，会以timeout为准
    14.         max-idle: 50     # 连接池中的最大空闲连接
    15.     timeout: 1200        # 连接超时时间(单位:毫秒)

    5.1 自定义注解

    1. package com.kang.redis.annotation;
    2. ​
    3. import java.lang.annotation.*;
    4. ​
    5. /**
    6.  * @Author Emperor Kang
    7.  * @ClassName NonRepeatSubmit
    8.  * @Description 防止重复提交注解
    9.  * @Date 2022/8/24 15:03
    10.  * @Version 1.0
    11.  * @Motto 让营地比你来时更干净
    12.  */
    13. @Documented
    14. @Target(ElementType.METHOD) //应用在方法上
    15. @Retention(RetentionPolicy.RUNTIME) //保留到虚拟机运行时,可通过反射获取
    16. public @interface NonRepeatSubmit {
    17.     /**
    18.      * 支持两种防重复提交方式:
    19.      *  1.方法参数
    20.      *  2.令牌
    21.      */
    22.     enum Type {PARAM,TOKEN}
    23. ​
    24.     /**
    25.      * 默认防重复提交,是方法参数
    26.      * @return
    27.      */
    28.     Type limitType() default Type.PARAM;
    29. ​
    30.     /**
    31.      * 加锁过期时间,默认是5s
    32.      * @return
    33.      */
    34.     long lockTime() default 5;
    35. }

    5.2 编辑切面

    1. package com.kang.redis.aop;
    2. ​
    3. import com.kang.redis.annotation.NonRepeatSubmit;
    4. import com.kang.redis.exception.ConfirmTokenException;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.apache.commons.lang3.StringUtils;
    7. import org.aspectj.lang.ProceedingJoinPoint;
    8. import org.aspectj.lang.annotation.Around;
    9. import org.aspectj.lang.annotation.Aspect;
    10. import org.aspectj.lang.annotation.Pointcut;
    11. import org.springframework.beans.factory.annotation.Autowired;
    12. import org.springframework.data.redis.core.StringRedisTemplate;
    13. import org.springframework.stereotype.Component;
    14. import org.springframework.web.context.request.RequestContextHolder;
    15. import org.springframework.web.context.request.ServletRequestAttributes;
    16. ​
    17. import javax.servlet.http.HttpServletRequest;
    18. ​
    19. import static com.kang.redis.constant.RedisKeyConstant.SUBMIT_ORDER_TOKEN_KEY;
    20. ​
    21. /**
    22.  * @Author Emperor Kang
    23.  * @ClassName NonRepeatSubmitAspect
    24.  * @Description 利用切面对使用自定义注解的地方防止重复提交
    25.  * @Date 2022/8/24 15:44
    26.  * @Version 1.0
    27.  * @Motto 让营地比你来时更干净
    28.  */
    29. @Aspect
    30. @Component
    31. @Slf4j
    32. @SuppressWarnings("all")
    33. public class NonRepeatSubmitAspect {
    34.     @Autowired
    35.     private StringRedisTemplate redisTemplate;
    36. ​
    37.     /**
    38.      * 定义 @Pointcut注解表达式, 通过特定的规则来筛选连接点, 就是Pointcut，选中那几个你想要的方法
    39.      * 在程序中主要体现为书写切入点表达式（通过通配、正则表达式）过滤出特定的一组 JointPoint连接点
    40.      * 方式一：@annotation：当执行的方法上拥有指定的注解时生效(本次采用该方法)
    41.      * 方式二：execution：一般用于指定方法的执行
    42.      */
    43.     @Pointcut("@annotation(nonRepeatSubmit)")
    44.     public void pointCutNonRepeatSubmit(NonRepeatSubmit nonRepeatSubmit){}
    45. ​
    46.     /**
    47.      * 环绕通知,围绕方法执行
    48.      * 两种环绕方式:
    49.      * 方式一：单用 @Around("execution(* com.kang.redis.controller.*.*(..))")可以
    50.      * 方式二：用@Pointcut和@Around联合注解也可以(本地采用这个)
    51.      * 防重复提交的两种方式
    52.      * 方式一：加锁 固定时间内不能重复提交
    53.      * 方式二：先请求获取token，这边再删除token,删除成功则是第一次提交
    54.      * @param joinPoint
    55.      * @param nonRepeatSubmit
    56.      * @return
    57.      */
    58.     @Around("pointCutNonRepeatSubmit(nonRepeatSubmit)")
    59.     public Object around(ProceedingJoinPoint joinPoint,NonRepeatSubmit nonRepeatSubmit){
    60.         try {
    61.             ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    62.             if(servletRequestAttributes == null){
    63.                 throw new ConfirmTokenException("AOP拦截:无法获取当前请求request");
    64.             }
    65.             HttpServletRequest request =  servletRequestAttributes.getRequest();
    66.             //一般都是从request中获取当前用户ID
    67.             String userId = "0001";
    68.             //用于记录成功还是失败
    69.             boolean result = false;
    70.             //防重复提交的类型
    71.             String type = nonRepeatSubmit.limitType().name();
    72.             //注解中有默认配置所以不用考虑isBlank的情况
    73.             if(type.equals(NonRepeatSubmit.Type.PARAM.name())){
    74.                 //方式一，参数形式防重提交
    75.                 log.info("AOP拦截:采用参数形式防重复提交");
    76.             } else {
    77.                 //方式二，令牌形式防重提交
    78.                 String token = request.getHeader("token");
    79.                 if(StringUtils.isBlank(token)){
    80.                     throw new ConfirmTokenException("AOP拦截:token为空,非法请求");
    81.                 }
    82.                 String key = String.format(SUBMIT_ORDER_TOKEN_KEY,userId,token);
    83.                 /**
    84.                  * 只有第一次提交时才会删除成功
    85.                  * 方式一：不用lua脚本获取再判断，之前是因为 key组成是 order:submit:accountNo, value是对应的token，所以需要先获取值，再判断
    86.                  * 方式二：可以直接key是 order:submit:accountNo:token,然后直接删除成功则完成
    87.                  */
    88.                 result = redisTemplate.delete(key);
    89.             }
    90.             if(!result){
    91.                 log.error("AOP拦截:请求重复提交");
    92.                 log.info("AOP拦截:环绕该方法进行通知");
    93.                 throw new ConfirmTokenException("AOP拦截:请求重复提交");
    94.             }
    95.             log.info("AOP拦截:方法执行前");
    96.             Object object = joinPoint.proceed();
    97.             log.info("AOP拦截:方法执行后获得结果为:{}",object);
    98.             return object;
    99.         } catch (Throwable e) {
    100.             log.error("AOP拦截:执行出错",e);
    101.             return e.getMessage();
    102.         }
    103.     }
    104. }

    5.3 自定义异常类

    1. package com.kang.redis.exception;
    2. ​
    3. /**
    4.  * @Author Emperor Kang
    5.  * @ClassName ConfirmToeknException
    6.  * @Description 自定义异常
    7.  * @Date 2022/8/24 16:22
    8.  * @Version 1.0
    9.  * @Motto 让营地比你来时更干净
    10.  */
    11. public class ConfirmTokenException extends Exception{
    12.     public ConfirmTokenException() {
    13.         super();
    14.     }
    15. ​
    16.     public ConfirmTokenException(String message) {
    17.         super(message);
    18.     }
    19. ​
    20.     public ConfirmTokenException(String message, Throwable cause) {
    21.         super(message, cause);
    22.     }
    23. ​
    24.     public ConfirmTokenException(Throwable cause) {
    25.         super(cause);
    26.     }
    27. ​
    28.     protected ConfirmTokenException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    29.         super(message, cause, enableSuppression, writableStackTrace);
    30.     }
    31. }

    5.4 redis的一些配置类(StringRedisTemplate用不到)

    1. package com.kang.redis.config;
    2. ​
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.connection.RedisConnectionFactory;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.data.redis.serializer.RedisSerializer;
    8. ​
    9. /**
    10.  * @Author Emperor Kang
    11.  * @ClassName RedisConfig
    12.  * @Description redis配置类
    13.  * @Date 2022/8/11 11:17
    14.  * @Version 1.0
    15.  * @Motto 让营地比你来时更干净
    16.  */
    17. @Configuration
    18. public class RedisConfig {
    19.     @Bean
    20.     public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    21.         RedisTemplate redisTemplate = new RedisTemplate<>();
    22.         redisTemplate.setConnectionFactory(redisConnectionFactory);
    23.         redisTemplate.setKeySerializer(RedisSerializer.string());
    24.         redisTemplate.setValueSerializer(RedisSerializer.string());
    25. ​
    26.         redisTemplate.setHashKeySerializer(RedisSerializer.string());
    27.         redisTemplate.setHashValueSerializer(RedisSerializer.string());
    28. ​
    29.         redisTemplate.afterPropertiesSet();
    30.         return redisTemplate;
    31.     }
    32. }

    5.4 控制器编写

    1. package com.kang.redis.controller;
    2. ​
    3. import cn.hutool.core.lang.UUID;
    4. import com.alibaba.fastjson.JSON;
    5. import com.kang.redis.annotation.NonRepeatSubmit;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.data.redis.core.StringRedisTemplate;
    9. import org.springframework.web.bind.annotation.GetMapping;
    10. import org.springframework.web.bind.annotation.PostMapping;
    11. import org.springframework.web.bind.annotation.RequestMapping;
    12. import org.springframework.web.bind.annotation.RestController;
    13. ​
    14. import java.util.ArrayList;
    15. import java.util.HashMap;
    16. import java.util.List;
    17. import java.util.Map;
    18. import java.util.concurrent.TimeUnit;
    19. ​
    20. import static com.kang.redis.constant.RedisKeyConstant.SUBMIT_ORDER_TOKEN_KEY;
    21. ​
    22. /**
    23.  * @Author Emperor Kang
    24.  * @ClassName NonRepeatSubmitController
    25.  * @Description 提前获取令牌用于防重复提交
    26.  * @Date 2022/8/24 15:16
    27.  * @Version 1.0
    28.  * @Motto 让营地比你来时更干净
    29.  */
    30. @RestController
    31. @RequestMapping("/submit")
    32. @Slf4j
    33. public class NonRepeatSubmitController {
    34.     @Autowired
    35.     private StringRedisTemplate redisTemplate;
    36. ​
    37.     /**
    38.      * 生成token
    39.      * @return
    40.      */
    41.     @GetMapping("token")
    42.     public String getOrderToken(){
    43.         //假设该用户的userId="0001"
    44.         String userId = "0001";
    45.         //用UUID作为token
    46.         String token = UUID.randomUUID().toString().replaceAll("-","");
    47.         //组装存入redis的key
    48.         String key = String.format(SUBMIT_ORDER_TOKEN_KEY,userId,token);
    49.         log.info("生成的key为:{}",key);
    50.         //令牌的有效时间是30分钟
    51.         redisTemplate.opsForValue().set(key,String.valueOf(Thread.currentThread().getId()),30, TimeUnit.MINUTES);
    52.         return token;
    53.     }
    54. ​
    55.     /**
    56.      * add添加方法
    57.      * @return
    58.      */
    59.     @PostMapping("add")
    60.     @NonRepeatSubmit(limitType = NonRepeatSubmit.Type.TOKEN,lockTime = 10)
    61.     public String getUserInfo(){
    62.         List db = new ArrayList<>();
    63.         Map map = new HashMap<>();
    64.         map.put("name","齐景春");
    65.         map.put("age","10000");
    66.         map.put("message","插入成功");
    67.         db.add(map);
    68.         log.info("该数据插入数据库成功");
    69.         return JSON.toJSONString(db);
    70.     }
    71. ​
    72. }
      73.  

      6.测试Token的方式
       

      获取token
       

       
       

       

      第一次添加add
       

       

       
       

      第二次添加
       

        
       

       

      日志变化
       

       

       其他部分后续再补充,token的方式至此结束
       

      
                
                    
                

                
    73. 

                    相关阅读:
      
                    
9月27日复习                            
      
创建第一个 Cypress 应用后使用命令行 npx Cypress open 报错的原因分析                            
      
C#学习笔记--变量类型的转换                            
      
MyBatis                            
      
【初识 Docker | 基础篇】 Docker 搭建仓库                            
      
02.机器学习原理（复习）                            
      
ELK搭建                            
      
助力，NTP网络时间服务器（GPS北斗时钟）助力精准大数据                            
      
MySQL及MySQLworkbench安装教程                            
      
上海亚商投顾：A股缩量调整 AIGC、Web3.0概念抢眼                            
      
                          
                
      74. 
                
    74. 
                    原文地址：https://blog.csdn.net/LuckFairyLuckBaby/article/details/126510264
                
      75.