Java后台防止客户端重复请求、提交表单

前言

在Web / App项目中，有一些请求或操作会对数据产生影响（比如新增、删除、修改），针对这类请求一般都需要做一些保护，以防止用户有意或无意的重复发起这样的请求导致的数据错乱。

常见处理方案

1.客户端

　　例如表单提交后将提交按钮设为disable 等等方法...

2.服务端

　　前端的限制仅能解决少部分问题，且不够彻底，后端自有的防重复处理措施必不可少，义不容辞。

　　在此提供一个我在项目中用到的方案。简单来说就是判断请求url和数据是否和上一次相同。

方法步骤

1.主要逻辑：

　　给所有的url加一个拦截器，每次请求将url存入session，下次请求验证url数据是否相同，相同则拒绝访问。

　　当然，我在此基础上做了一些优化，比如：

　　　　使用session有局限性，用户量大了以后服务器会撑不住，在此我使用了redis来替换。

　　　　加入了token令牌机制。

2.实现步骤：

• 2.1自定义一个注解

•  1 /**
   2  * @Title: SameUrlData
   3  * @Description: 自定义注解防止表单重复提交
   4  * @Auther: xhq
   5  * @Version: 1.0
   6  * @create 2019/3/26 10:43
   7  */
   8 @Inherited
   9 @Target(ElementType.METHOD)
  10 @Retention(RetentionPolicy.RUNTIME)
  11 @Documented
  12 public @interface SameUrlData {
  13
  14 }

• 2.2自定义拦截器类
  • 检查此接口调用的方法是否使用了SameUrlData注解，若没有使用，表示此接口不需要校验；
  • 若使用了注解，获取请求url+参数，并去除一直在变化的参数(比如时间戳timeStamp和签名sign)
  • 检查参数中是否有token参数（token代表不同的用户的唯一标识），没有直接放行
  • 有token参数，将token+url作为redis的key，url+参数作为value存入redis，并设定自动销毁时间
  • （此处如果项目中没有redis，可参照我的另外一篇博客可解决：https://www.cnblogs.com/xhq1024/p/11115755.html）
  • 再次访问进行验证是否重复请求　　

•   1 import com.alibaba.fastjson.JSONObject;
    2 import com.tuohang.hydra.framework.common.spring.SpringKit;
    3 import com.tuohang.hydra.toolkit.basis.string.StringKit;
    4 import org.slf4j.Logger;
    5 import org.slf4j.LoggerFactory;
    6 import org.springframework.data.redis.core.StringRedisTemplate;
    7 import org.springframework.stereotype.Component;
    8 import org.springframework.web.method.HandlerMethod;
    9 import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
   10
   11 import javax.servlet.http.HttpServletRequest;
   12 import javax.servlet.http.HttpServletResponse;
   13 import java.lang.reflect.Method;
   14 import java.util.HashMap;
   15 import java.util.Iterator;
   16 import java.util.Map;
   17 import java.util.concurrent.TimeUnit;
   18
   19 /**
   20  * @Title: 防止用户重复提交数据拦截器
   21  * @Description: 将用户访问的url和参数结合token存入redis，每次访问进行验证是否重复请求接口
   22  * @Auther: xhq
   23  * @Version: 1.0
   24  * @create 2019/3/26 10:35
   25  */
   26 @Component
   27 public class SameUrlDataInterceptor extends HandlerInterceptorAdapter {
   28
   29     private static Logger LOG = LoggerFactory.getLogger(SameUrlDataInterceptor.class);
   30
   31     /**
   32      * 是否阻止提交,fasle阻止,true放行
   33      * @return
   34      */
   35     @Override
   36     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
   37         if (handler instanceof HandlerMethod) {
   38             HandlerMethod handlerMethod = (HandlerMethod) handler;
   39             Method method = handlerMethod.getMethod();
   40             SameUrlData annotation = method.getAnnotation(SameUrlData.class);
   41             if (annotation != null) {
   42                 if(repeatDataValidator(request)){
   43                     //请求数据相同
   44                     LOG.warn("please don't repeat submit,url:"+ request.getServletPath());
   45                     JSONObject result = new JSONObject();
   46                     result.put("statusCode","500");
   47                     result.put("message","请勿重复请求");
   48                     response.setCharacterEncoding("UTF-8");
   49                     response.setContentType("application/json; charset=utf-8");
   50                     response.getWriter().write(result.toString());
   51                     response.getWriter().close();
   52 //                    拦截之后跳转页面
   53 //                    String formRequest = request.getRequestURI();
   54 //                    request.setAttribute("myurl", formRequest);
   55 //                    request.getRequestDispatcher("/WebRoot/common/error/jsp/error_message.jsp").forward(request, response);
   56                     return false;
   57                 }else {//如果不是重复相同数据
   58                     return true;
   59                 }
   60             }
   61             return true;
   62         } else {
   63             return super.preHandle(request, response, handler);
   64         }
   65     }
   66     /**
   67      * 验证同一个url数据是否相同提交,相同返回true
   68      * @param httpServletRequest
   69      * @return
   70      */
   71     public boolean repeatDataValidator(HttpServletRequest httpServletRequest){
   72         //获取请求参数map
   73         Map<String, String[]> parameterMap = httpServletRequest.getParameterMap();
   74         Iterator<Map.Entry<String, String[]>> it = parameterMap.entrySet().iterator();
   75         String token = "";
   76         Map<String, String[]> parameterMapNew = new HashMap<>();
   77         while(it.hasNext()){
   78             Map.Entry<String, String[]> entry = it.next();
   79             if(!entry.getKey().equals("timeStamp") && !entry.getKey().equals("sign")){
   80                 //去除sign和timeStamp这两个参数，因为这两个参数一直在变化
   81                 parameterMapNew.put(entry.getKey(), entry.getValue());
   82                 if(entry.getKey().equals("token")) {
   83                     token = entry.getValue()[0];
   84                 }
   85             }
   86         }
   87         if (StringKit.isBlank(token)){
   88             //如果没有token，直接放行
   89             return false;
   90         }
   91         //过滤过后的请求内容
   92         String params = JSONObject.toJSONString(parameterMapNew);
   93
   94         System.out.println("params==========="+params);
   95
   96         String url = httpServletRequest.getRequestURI();
   97         Map<String,String> map = new HashMap<>();
   98         //key为接口，value为参数
   99         map.put(url, params);
  100         String nowUrlParams = map.toString();
  101
  102         StringRedisTemplate smsRedisTemplate = SpringKit.getBean(StringRedisTemplate.class);
  103         String redisKey = token + url;
  104         String preUrlParams = smsRedisTemplate.opsForValue().get(redisKey);
  105         if(preUrlParams == null){
  106             //如果上一个数据为null,表示还没有访问页面
  107             //存放并且设置有效期，2秒
  108             smsRedisTemplate.opsForValue().set(redisKey, nowUrlParams, 2, TimeUnit.SECONDS);
  109             return false;
  110         }else{//否则，已经访问过页面
  111             if(preUrlParams.equals(nowUrlParams)){
  112                 //如果上次url+数据和本次url+数据相同，则表示重复添加数据
  113                 return true;
  114             }else{//如果上次 url+数据 和本次url加数据不同，则不是重复提交
  115                 smsRedisTemplate.opsForValue().set(redisKey, nowUrlParams, 1, TimeUnit.SECONDS);
  116                 return false;
  117             }
  118         }
  119     }
  120 }

• 2.3注册拦截器
  

   1 @Configuration
   2 public class WebMvcConfigExt extends WebMvcConfig {
   3
   4     /**
   5      * 防止重复提交拦截器
   6      */
   7     @Autowired
   8     private SameUrlDataInterceptor sameUrlDataInterceptor;
   9
  10     @Override
  11     public void addInterceptors(InterceptorRegistry registry) {
  12         // 避开静态资源
  13         List<String> resourcePaths = defineResourcePaths();
  14         registry.addInterceptor(sameUrlDataInterceptor).addPathPatterns("/**").excludePathPatterns(resourcePaths);// 重复请求
  15     }
  16
  17     /**
  18      * 自定义静态资源路径
  19      *
  20      * @return
  21      */
  22     @Override
  23     public List<String> defineResourcePaths() {
  24         List<String> patterns = new ArrayList<>();
  25         patterns.add("/assets/**");
  26         patterns.add("/upload/**");
  27         patterns.add("/static/**");
  28         patterns.add("/common/**");
  29         patterns.add("/error");
  30         return patterns;
  31     }
  32 }

• 在相应方法上加@SameUrlData注解

  @SameUrlData
  @ResponseBody
  @RequestMapping(value = "/saveOrUpdate")
  public String saveOrUpdate(){
  }