由防止表单重复提交引发的一系列问题--servletRequest的复制、body值的获取

@Time:2019年1月4日 16:19:19

@Author:QGuo

 

背景：最开始打算写个防止表单重复提交的拦截器；网上见到一种不错的方式，比较合适前后端分离，校验在后台实现；

我在此基础上，将key，value。Objects.hashCode()了下

因为request的body 可能太大，过长；

但不保证存在不同的object生成的哈希值却相同，但是我们目的只是为了防止重复提交而已，不同对象生成哈希值相同的机率很小。

 

==========================代码==============================

1、HttpServletRequestReplacedFilter 过滤器.

目的：post请求时，复制request；注意代码中的注释部分；

package com.kdgz.service;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @author QGuo
 * @date 2019/1/3 15:04
 */
public class HttpServletRequestReplacedFilter implements Filter {
    @Override
    public void destroy() {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if (request instanceof HttpServletRequest) {
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            String contentType = request.getContentType();

            if (contentType != null && contentType.contains("application/x-www-form-urlencoded")) {
                //如果是application/x-www-form-urlencoded, 参数值在request body中以 a=1&b=2&c=3...形式存在，
                //若直接构造BodyReaderHttpServletRequestWrapper，在将流读取并存到copy字节数组里之后,
                //httpRequest.getParameterMap()将返回空值！
                //若运行一下 httpRequest.getParameterMap(), body中的流将为空! 所以两者是互斥的！
                request.getParameterMap();
            }
            if ("POST".equals(httpServletRequest.getMethod().toUpperCase())) {
                requestWrapper = new BodyHttpServletRequestWrapper((HttpServletRequest) request);
            }
        }

        if (requestWrapper == null) {
            chain.doFilter(request, response);
        } else {
            chain.doFilter((HttpServletRequest)requestWrapper, response);
        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {}
}

HttpServletRequestReplacedFilter

 

2、HttpServletRequestWrapper --复制ServletRequest

目的在于：使servletRequest可以重复获取inputStream、reader；

 package com.kdgz.service;

 import javax.servlet.ReadListener;
 import javax.servlet.ServletInputStream;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletRequestWrapper;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.nio.charset.Charset;
 import java.util.Enumeration;
 import java.util.Map;

 /**
  * @author QGuo
  * @date 2019/1/3 15:05
  */
 public class BodyHttpServletRequestWrapper extends HttpServletRequestWrapper {

     private byte[] body;

     public byte[] getBody() { return body; }

     public void setBody(byte[] body) { this.body = body; }

     public BodyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
         super(request);
         body = this.getBodyString(request).getBytes(Charset.forName("UTF-8"));
     }

     @Override
     public BufferedReader getReader() throws IOException {
         return new BufferedReader(new InputStreamReader(getInputStream(),"UTF-8"));
     }

     @Override
     public ServletInputStream getInputStream() throws IOException {

         final ByteArrayInputStream bais = new ByteArrayInputStream(this.body);

         return new ServletInputStream() {
             @Override
             public boolean isFinished() {  return false; }

             @Override
             public boolean isReady() { return false; }

             @Override
             public void setReadListener(ReadListener readListener) {}

             @Override
             public int read() throws IOException { return bais.read(); }
         };
     }

     @Override
     public String getHeader(String name) { return super.getHeader(name); }

     @Override
     public Enumeration<String> getHeaderNames() { return super.getHeaderNames(); }

     @Override
     public Enumeration<String> getHeaders(String name) { return super.getHeaders(name); }

     @Override
     public Map<String, String[]> getParameterMap() { return super.getParameterMap(); }

     public String getBodyString(ServletRequest request) {
         StringBuilder sb = new StringBuilder();
         InputStream inputStream = null;
         BufferedReader reader = null;
         try {
             inputStream = request.getInputStream();
             reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
             String line = "";
             while ((line = reader.readLine()) != null) {
                 sb.append(line);
             }
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (inputStream != null) {
                 try {
                     inputStream.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (reader != null) {
                 try {
                     reader.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return sb.toString();
     }
 }

HttpServletRequestWrapper

3、web.xml 中添加过滤器

   <filter>
     <filter-name>httpServletRequestFilter</filter-name>
     <filter-class>com.kdgz.service.HttpServletRequestReplacedFilter</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>httpServletRequestFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

4、添加自定义注解

 package com.kdgz.annotation;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
  * @author QGuo
  * @date 2018/12/24 13:58
  * 一个用户 相同url 同时提交 相同数据 验证
  */
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface SameUrlData {
 }

@SameUrlData

5、添加拦截器

 package com.kdgz.service;

 import com.alibaba.fastjson.JSON;
 import com.kdgz.annotation.SameUrlData;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;

 /**
  * 一个用户 相同url 同时提交 相同数据 验证
  * 主要通过 session中保存到的url 和 请求参数。如果和上次相同，则是重复提交表单
  *
  * @author QGuo
  * @date 2018/12/24 14:02
  */
 public class SameUrlDataInterceptor extends HandlerInterceptorAdapter {
     @Resource
     StringRedisTemplate stringRedisTemplate;

     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
         if (handler instanceof HandlerMethod) {
             HandlerMethod handlerMethod = (HandlerMethod) handler;
             Method method = handlerMethod.getMethod();
             SameUrlData annotation = method.getAnnotation(SameUrlData.class);
             if (annotation != null) {
                 if (repeatDataValidator(request)) {//如果重复相同数据
                     //在此可添加response响应内容，提醒用户重复提交了
                     return false;
                 } else
                     return true;
             }
             return true;
         } else {
             return super.preHandle(request, response, handler);
         }
     }

     /**
      * 验证同一个url数据是否相同提交  ,相同返回true
      *
      * @param httpServletRequest
      * @return
      */
     public boolean repeatDataValidator(HttpServletRequest httpServletRequest) throws IOException {
         Map<String, String[]> parameterMap = new HashMap(httpServletRequest.getParameterMap());
         //删除参数中的v；（v参数为随机生成的字符串，目的是为了每次访问都是最新值，既然要防止重复提交，需要剔除此参数）
         if (parameterMap.containsKey("v"))
             parameterMap.remove("v");
         //每一位登录者都有唯一一个token认证
         String tokens = "";
         if (parameterMap.get("token").length > 0)
             tokens = parameterMap.get("token")[0];
         String method = httpServletRequest.getMethod().toUpperCase();//请求类型，GET、POST
         String params;
         if (StringUtils.equals(method, "POST")) {//post请求时
             BodyHttpServletRequestWrapper requestWrapper = new BodyHttpServletRequestWrapper((HttpServletRequest) httpServletRequest);
             byte[] bytes = requestWrapper.getBody();
             if (bytes.length != 0) {
                 params = JSON.toJSONString(new String(bytes, "UTF-8").trim());
             } else {//若body被清空，则说明参数全部被填充到Parameter集合中了
                 /**
                  * 当满足一下条件时，就会被填充到parameter集合中
                  * 1：是一个http/https请求
                  * 2：请求方法是post
                  * 3：请求类型(content-Type)是application/x-www-form-urlencoded
                  * 4: Servlet调用了getParameter系列方法
                  */
                 Map<String, String[]> map = new HashMap(requestWrapper.getParameterMap());
                 // 去除 v 参数
                 if (map.containsKey("v"))
                     map.remove("v");
                 params = JSON.toJSONString(map);
             }
         } else {
             params = JSON.toJSONString(parameterMap);
         }

         String url = String.valueOf(Objects.hashCode(httpServletRequest.getRequestURI() + tokens));
         Map<String, String> map = new HashMap<String, String>();
         map.put(url, params);
         //防止参数过多，string过大；现将储存为 hash编码；
         String nowUrlParams = String.valueOf(Objects.hashCode(map));
         String preUrlParams = stringRedisTemplate.opsForValue().get(url);
         if (preUrlParams == null) {//如果上一个数据为null,表示还没有访问页面
             //设置过期时间为3分钟
             stringRedisTemplate.opsForValue().set(url, nowUrlParams, 3, TimeUnit.MINUTES);
             return false;
         } else if (preUrlParams.equals(nowUrlParams)) {//否则，已经访问过页面
             //如果上次url+数据和本次url+数据相同，则表示重复添加数据
             return true;
         } else {//如果上次 url+数据 和本次url加数据不同，则不是重复提交，更新
             stringRedisTemplate.opsForValue().set(url, nowUrlParams, 3, TimeUnit.MINUTES);
             return false;
         }
     }
 }

SameUrlDataInterceptor

使用的时候，只要在接口上，添加注解即可

例如：

@RequestMapping(value = "v1.0/monGraphSave")
@SameUrlData
public AjaxMessage monGraphSave(@RequestBody MonGraphFB monGraphFB){} 

====================代码结束===================

 

整理至此，主要有以下注意点；

①、得考虑post请求参数获取的特殊性

②、request.getInputStream() 只能获取一次，要想可以多次读取，得继承HttpServletRequestWrapper，读出来--放回去

③、过滤器的目的是可以直接读取request里面的body

④、request参数body可能很大，可以取hash值。

⑤、key、value的存储，需要设置过期时间；

 

心得：

其实我觉得防止表单重复提交这个功能，作用不是特别大；因为只要随便加一个参数，就可以把需要的参数重复添加进系统中；

只能做到，防止用户误操作，点击了多次这种情况；（一般前端也会做处理的，但万一前端抽风自动发起了多次请求呢）；

只能说一定程度上 更加完善吧

 

改进：

可以在SameUrlDataInterceptor拦截器中，添加response响应内容，让用户知道自己重复提交了。

很简单不举例了；