一个注解，两种实现方式完美解决重复提交问题-51CTO.COM

环境：Springboot3.0.5

什么是接口防重

接口防重是指在一定时间内只允许执行一次接口请求。这是为了防止由于重复提交和重复处理产生重复数据或相应错误。实现接口防重可以采用以下方法：

使用唯一标识符：在请求中包含一个唯一标识符（例如请求token），然后在对应接口判断该唯一值在一定时间内是否被消费过，如果已被消费，则拒绝该请求。
使用时间戳、计数器等机制：记录请求的时间或次数，并在一定范围内拒绝重复请求。
采用Spring AOP理念：实现请求的切割，在请求执行到某个方法或某层时，开始拦截并进行防重处理。

这些方法有助于确保系统的一致性和稳定性，防止数据的重复提交和处理。

幂等与防重

API接口的幂等性和防重性是两个不同的概念，尽管它们在某些方面有重叠之处。

幂等性
幂等性是指一个操作或API请求，无论执行一次还是多次，结果都是相同的。在API设计中，幂等性是一种非常重要的属性，因为它确保了在重试或并发请求时，系统状态不会出现不一致的情况。

在实现幂等性时，通常采用以下方法：

在请求中包含一个唯一标识符（例如请求ID），以便在处理请求时能够识别和防止重复处理。
使用乐观锁或悲观锁机制来保证数据的一致性。
对于更新操作，可以通过比较新旧数据来判断是否有变化，只有当数据发生改变时才执行更新操作。
防重性
防重性是指在一定时间内只允许执行一次操作或请求。它主要用于防止重复提交和重复处理。与幂等性不同，防重性主要关注的是防止数据重复，而幂等性则关注任何多次执行的结果都是相同的。

技术实现

方式1：通过AOP方式

自定义注解

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface PreventDuplicate {
  
  /**
   * 唯一标识通过header传递时的key
   * 
   * @return
   */
  String header() default "token" ;
  
  /**
   * 唯一标识通过请求参数传递时的key
   * 
   * @return
   */
  String param() default "token" ;
}

自定义AOP切面

@Component
@Aspect
public class PreventDuplicateAspect {


  public static final String PREVENT_PREFIX_KEY = "prevent:" ;
  
  private final StringRedisTemplate stringRedisTemplate ;
  private final HttpServletRequest request ;
  
  public PreventDuplicateAspect(StringRedisTemplate stringRedisTemplate, HttpServletRequest request) {
    this.stringRedisTemplate = stringRedisTemplate ;
    this.request = request ;
  }
  
  @Around("@annotation(prevent)")
  public Object preventDuplicate(ProceedingJoinPoint pjp, PreventDuplicate prevent) throws Throwable {
    
    String key = prevent.header() ;
    String value = null ;
    if (key != null && key.length() > 0) {
      value = this.request.getHeader(key) ;
    } else {
      key = prevent.param() ;
      if (key != null && key.length() > 0) {
        value = this.request.getParameter(key) ;
      }
    }
    
    if (value == null || "".equals(value.trim())) {
      return "非法请求" ;
    }


    // 拼接rediskey
    String prevent_key = PREVENT_PREFIX_KEY + value ;
    // 判断redis中是否存在当前请求中携带的唯一标识数据, 删除成功则存在
    Boolean result = this.stringRedisTemplate.delete(prevent_key) ;
    if (result != null && result.booleanValue()) {
      return pjp.proceed() ;
    } else {
      return "请不要重复提交" ;
    }
  }
  
}

生成唯一标识接口

@RestController
@RequestMapping("/generate")
public class GenerateController {


  private final StringRedisTemplate stringRedisTemplate ;
  public GenerateController(StringRedisTemplate stringRedisTemplate) {
    this.stringRedisTemplate = stringRedisTemplate ;
  }
  
  @GetMapping("/token")
  public String token() {
    String token = UUID.randomUUID().toString().replace("-", "") ;
    // 将生成的token存入redis中，设置有效期5分钟
    this.stringRedisTemplate.opsForValue().setIfAbsent(PreventDuplicateAspect.PREVENT_PREFIX_KEY + token, token, 5 * 60, TimeUnit.SECONDS) ;
    return token ;
  }
  
}

业务接口

@RestController
@RequestMapping("/prevent")
public class PreventController {


  @PreventDuplicate
  @GetMapping("/index")
  public Object index() {
    return "index success" ;
  }
  
}

测试

先调用生成唯一接口获取token值

图片

调用业务接口，携带token值

第一次访问, 正常

再次访问

方式2：通过拦截器实现

自定义拦截器

@Component
public class PreventDuplicateInterceptor implements HandlerInterceptor {


  private final StringRedisTemplate stringRedisTemplate ;
  public PreventDuplicateInterceptor(StringRedisTemplate stringRedisTemplate) {
    this.stringRedisTemplate = stringRedisTemplate ;
  }
  
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    if (handler instanceof HandlerMethod hm) {
      if (hm.hasMethodAnnotation(PreventDuplicate.class)) {
        PreventDuplicate pd = hm.getMethodAnnotation(PreventDuplicate.class) ;
        
        String key = pd.header() ;
        String value = null ;
        if (key != null && key.length() > 0) {
          value = request.getHeader(key) ;
        } else {
          key = pd.param() ;
          if (key != null && key.length() > 0) {
            value = request.getParameter(key) ;
          }
        }
        
        if (value == null || "".equals(value.trim())) {
          response.setContentType("text/plain;charset=utf-8") ;
          response.getWriter().println("非法请求") ;
          return false ;
        }
        
        // 拼接rediskey
        String prevent_key = PreventDuplicateAspect.PREVENT_PREFIX_KEY + value ;
        // 判断redis中是否存在当前请求中携带的唯一标识数据, 删除成功则存在
        Boolean result = this.stringRedisTemplate.delete(prevent_key) ;
        if (result != null && result.booleanValue()) {
          return true ;
        } else {
          response.setContentType("text/plain;charset=utf-8") ;
          response.getWriter().println("请不要重复提交") ;
          return false ;
        }
      }
    }
    return true ;
  }
  
}

配置拦截器

@Component
public class PreventWebConfig implements WebMvcConfigurer {


  private final PreventDuplicateInterceptor duplicateInterceptor ;
  public PreventWebConfig(PreventDuplicateInterceptor duplicateInterceptor) {
    this.duplicateInterceptor = duplicateInterceptor ;
  }
  
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(this.duplicateInterceptor).addPathPatterns("/**") ;
  }
  
}

测试

获取token

第一次请求

再次请求

完毕！！！