java 后端防止前端重复提交数据

//自定义一个防止重复提交的注解

package com.mingwen.common.SubmitMore;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* @description 防止表单重复提交注解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface CannotSubmit{

// 保存重复提交标记默认为需要保存
boolean save() default true;

}

//写一个防止重复提交的拦截器

package com.mingwen.common.SubmitMore;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import com.mingwen.common.exception.DuplicateSubmitException;

import cn.hutool.core.lang.UUID;
import lombok.extern.slf4j.Slf4j;

/**
* @description 防止表单重复提交拦截器
*/
@Aspect
@Component
@Slf4j
public class DuplicateSubmitAspect {
public static final String DUPLICATE_TOKEN_KEY = "duplicate_token_key";

//扫描controller层

@Pointcut("execution(public * com.mingwen.privatestock.controller..*(..))")

public void webLog() {
}

   @Before("webLog() && @annotation(submit)")
   public void before(final JoinPoint joinPoint, CannotSubmit submit) throws DuplicateSubmitException {
       if (submit != null) {
           Object[] args = joinPoint.getArgs();
           HttpServletRequest request = null;
           HttpServletResponse response = null;
           for (int i = 0; i < args.length; i++) {
               if (args[i] instanceof HttpServletRequest) {
                   request = (HttpServletRequest) args[i];
               }
               if (args[i] instanceof HttpServletResponse) {
                   response = (HttpServletResponse) args[i];
               }
           }

           boolean isSaveSession = submit.save();
           if (isSaveSession) {
               Object t = request.getSession().getAttribute(DUPLICATE_TOKEN_KEY);
               if (null == t) {
                   String uuid = UUID.randomUUID().toString();
                   request.getSession().setAttribute(DUPLICATE_TOKEN_KEY, uuid);
               } else {

                   throw new DuplicateSubmitException("请不要重复请求！");
               }
           }

}
}

   @AfterReturning("webLog() && @annotation(submit)")
   public void doAfterReturning(JoinPoint joinPoint, CannotSubmit submit) {
       // 处理完请求，返回内容

       if (submit != null) {
           Object[] args = joinPoint.getArgs();
           HttpServletRequest request = null;
           for (int i = 0; i < args.length; i++) {
               if (args[i] instanceof HttpServletRequest) {
                   request = (HttpServletRequest) args[i];
               }
           }
           boolean isSaveSession = submit.save();
           if (isSaveSession) {
               Object t = request.getSession().getAttribute(DUPLICATE_TOKEN_KEY);
               if (null != t) {
                   request.getSession(false).removeAttribute(DUPLICATE_TOKEN_KEY);
               }
           }
       }
   }
}

//自定义一个表单重复提交异常

/**
* @author wsj 自定义异常
*/
public class DuplicateSubmitException extends RuntimeException{

   public DuplicateSubmitException(String msg) {
       super(msg);
   }
}

//遇到重复提交的异常要将信息返回到前端显示拦截器抛的异常在controller是无法捕获到的所以这里统一异常捕获类控制器增强

@ControllerAdvice
@ResponseBody
@Slf4j
public class ExceptionCatch {

protected Map<String, Object> getResultObjectData(ResultCode result, Object pd, String msg) {
       Map<String, Object> resultData = new HashMap<>();
       resultData.put("code", result.getCode());
       resultData.put("message", result.getMsg());
       resultData.put("data", pd);
       return resultData;
   }

   // 捕获CustomException此类异常
   @ExceptionHandler(DuplicateSubmitException.class)
   public Map<String, Object> customException(DuplicateSubmitException bmException) {
       bmException.printStackTrace();
       // 记录日志
       log.error("catch exception:{}", "不可重复提交");
       return getResultObjectData(ResultCode.NO_SUBMIT, "", "不可重复提交");
   }

}

//测试controller

/**
   * 防止重复提交测试
   *
   * @param request
   * @return
   */
   @CannotSubmit
   @RequestMapping("/test")
   public Map<String, Object> test(HttpServletRequest request) {

//往request 里面存入每次请求的接口地址这样控制器能能拿到request里面的请求地址必须要的步骤
request.getSession().setAttribute("request Url", request.getRequestURL());

try {

//休眠的目的是让你自己在前端能有时间重复点击一下接口调用
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

Map<String, Object> map = new HashMap<>();

       map.put("request Url", request.getRequestURL());
       return map;
   }

//效果

接口快速点击两次

java 后端防止前端重复提交数据

猜你喜欢