由防止表單重復提交引發的一系列問題--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 {}
}

 

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();
    }
}

 

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 {
}

 

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;
        }
    }
}

 

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

例如：

@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響應內容，讓用戶知道自己重復提交了。

很簡單不舉例了；