springmvc 防止表单重复提交

      在网上查看了很多关于springmvc防止表单重复提交的例子，将其中的3个整合在一起，才算是一个完整的例子。因项目中暂时还没有这么个需求，特备注下来，以防以后用到时还要大量的漫无目的的去寻找例子。

实现原理为SpringMvc拦截器+注解的方式实现防止重复提交

实现机制是使用token（随机码）,简单说下:

(a)进入下单页,会生成一个token,同时存在两个地方:session(或redis也可以)和页面

(b)提交时,服务器接收到页面的token后,会和session中的token比较,相同则允许提交,同时删除session中的token;

(c)如果重复提交,则session中已经没有token(已被步骤b删除),那么校验不通过,则不会真正提交.

先创建一个注解：

package com.dinfo.interceptor;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Token {

    boolean save() default false;
    boolean remove() default false;

}

拦截器接口：

package com.dinfo.interceptor;

import java.lang.reflect.Method;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;


public class TokenInterceptor extends HandlerInterceptorAdapter {
    private static final Logger LOG = Logger.getLogger(Token.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            Token annotation = method.getAnnotation(Token.class);
            if (annotation != null) {
                boolean needSaveSession = annotation.save();
                if (needSaveSession) {
                    request.getSession(true).setAttribute("token", UUID.randomUUID().toString());
                }
                boolean needRemoveSession = annotation.remove();
                if (needRemoveSession) {
                    if (isRepeatSubmit(request)) {
                         LOG.warn("please don't repeat submit,url:"+ request.getServletPath());
                        return false;
                    }
                    request.getSession(true).removeAttribute("token");
                }
            }
            return true;
        } else {
            return super.preHandle(request, response, handler);
        }
    }

    private boolean isRepeatSubmit(HttpServletRequest request) {
        String serverToken = (String) request.getSession(true).getAttribute("token");
        if (serverToken == null) {
            return true;
        }
        String clinetToken = request.getParameter("token");
        if (clinetToken == null) {
            return true;
        }
        if (!serverToken.equals(clinetToken)) {
            return true;
        }
        return false;
    }

}

配置文件如下：

<!-- 拦截器配置 -->
<mvc:interceptors>
        <!-- 配置Token拦截器，防止用户重复提交数据 -->
        <mvc:interceptor>
            <mvc:mapping path="/**"/><!--这个地方时你要拦截得路径 我这个意思是拦截所有得URL-->
            <bean class="com.dinfo.interceptor.TokenInterceptor"/><!--class文件路径改成你自己写得拦截器路径！！ -->
        </mvc:interceptor>

</mvc:interceptors>

页面表单中需要添加如下：<input type="hidden" name="token" value="${token}" />

在需要生成token（通常是要点击提交得那个页面）得Controller中使用我们刚才自定义好得注解,贴代码:

@SuppressWarnings({ "unchecked", "finally", "rawtypes" })
    @RequestMapping("/SaveDataController/show")
    @Token(save=true)
    public String saveData(HttpServletRequest request,HttpServletResponse response,String task_id){
        
        Map map = new HashMap();
        System.out.println(task_id);
        try {
            map = saveDataService.queryByTaskId(task_id);
        } catch (Exception e) {
            e.printStackTrace();
            map.put("task_id", task_id);
            map.put("savetype", "");
            map.put("memoryCodes", "1");
            map.put("tablename", "");
            map.put("trowkey", "");
            map.put("columns", "");
            map.put("indextablename", "");
            map.put("irowkey", "");
            map.put("icolumns", "");
        } finally {
            request.setAttribute("map", map);
            return "savedata/index";
        }

    }

只要通过这个方法跳向得页面都是随机生成一个token,然后再真正再提交触发得方法上加入@token(remove=true),贴代码：

@RequestMapping("/SaveDataController/saveData")
    @ResponseBody
    @Token(remove=true)
    public void saveData(HttpServletRequest request,HttpServletResponse response,
                         String tablename,String trowkey,String columns,
                         String indextablename,String irowkey,String icolumns,
                         String task_id,String savetype,String memoryCodes){
        System.out.println(task_id);
        saveDataService.saveData(task_id,savetype,memoryCodes,tablename, trowkey, columns, indextablename, irowkey, icolumns);

    }

上面的只能防止单页面的重复提交，如果同时打开两个页面同时进行提交，则第二次提交总是失败，需要进行再次扩展，具体方法如下：

但是--

如果打开两个标签页,则这两个页面分别有一个token,并且是不同的(理论上是不同的),但是session中只有一份,

其中一个提交后,就会删除session中的token,那么另外一个页面提交时session中的token已为空,那么一定校验不通过.

根本原因:

在同一时刻,session中只存了一份token,而页面上可能有多个token(有n个页签,就会有n个不同的token).

既然找到了根本原因,那么也就自然而然产生了解决方案.

思路:session中不能只存储一份token,而是支持存储多个token

具体技术方案:

(1)每次进入下单页都会产生一个新的token,这个token都进入两个数据流:

--(a)传到页面,key是repeattoken

前端页面引用方式:

Html代码  

1. <input type="hidden" name="repeattoken" value="${Session.repeattoken!}" >  

 

 

--(b)存储到session(现在是增量,不会把原来的token替换掉)

(2)存储到session中的key应该与页面的key区分开来,使用"tokenpool"

优化之后的过滤器:

Java代码  

1. package com.chanjet.gov.filter;  
2.   
3. import com.chanjet.gov.util.StringUtil;  
4. import org.apache.log4j.Logger;  
5. import org.springframework.web.method.HandlerMethod;  
6. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;  
7.   
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10. import javax.servlet.http.HttpSession;  
11. import java.lang.reflect.Method;  
12. import java.util.UUID;  
13.   
14. /** 
15.  *     防止下单页重复提交 
16.  */  
17. public class RepeatTokenInterceptor  extends HandlerInterceptorAdapter {  
18.     /*** 
19.      * 用于前端页面接收服务器端的token 
20.      */  
21.     public static final String SESSION_KEY_REPEATTOKEN="repeattoken";  
22.     /*** 
23.      * 用于session存储n个token 
24.      */  
25.     public static final String SESSION_KEY_REPEATTOKEN_POOL = "tokenpool";  
26.     private static Logger log = Logger.getLogger(RepeatTokenInterceptor.class);  
27.   
28.     private void addRepeatToken(HttpServletRequest request, HttpServletResponse response){  
29.         HttpSession httpSession = request.getSession(true);  
30.         String token = (String) httpSession.getAttribute(SESSION_KEY_REPEATTOKEN_POOL);  
31.         System.out.println("addRepeatToken token:"+token);  
32.         String createdToken = UUID.randomUUID().toString();  
33.         httpSession.setAttribute(SESSION_KEY_REPEATTOKEN, createdToken);//给前端页面用的  
34.         if(StringUtil.isNullOrEmpty(token)){  
35.             httpSession.setAttribute(SESSION_KEY_REPEATTOKEN_POOL, createdToken);  
36.         }else{  
37.             httpSession.setAttribute(SESSION_KEY_REPEATTOKEN_POOL, createdToken + "###" + token);  
38.         }  
39.     }  
40.     private void removeRepeatToken(HttpServletRequest request, HttpServletResponse response){  
41.         HttpSession httpSession = request.getSession(true);  
42.         String token = (String) httpSession.getAttribute(SESSION_KEY_REPEATTOKEN_POOL);  
43.         System.out.println("removeRepeatToken token:"+token);  
44.         if(!StringUtil.isNullOrEmpty(token)){  
45.             String clientToken = (String) request.getParameter(SESSION_KEY_REPEATTOKEN);  
46.             System.out.println("removeRepeatToken serverToken:"+clientToken);  
47.             if (clientToken == null) {  
48.                 return;  
49.             }  
50.             token = token.replace(clientToken, "").replace("######", "###");  
51.             System.out.println("token:"+token);  
52.             httpSession.setAttribute(SESSION_KEY_REPEATTOKEN_POOL, token);  
53.         }  
54.     }  
55.     @Override  
56.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
57.         if (handler instanceof HandlerMethod) {  
58.             HandlerMethod handlerMethod = (HandlerMethod) handler;  
59.             Method method = handlerMethod.getMethod();  
60.             RepeatSubmitToken annotation = method.getAnnotation(RepeatSubmitToken.class);  
61.             if (annotation != null) {  
62.                 boolean needSaveSession = annotation.save();  
63.                 if (needSaveSession) {  
64.                     addRepeatToken(request,response);  
65.                 }  
66.                 boolean needRemoveSession = annotation.remove();  
67.                 if (needRemoveSession) {  
68.                     if (isRepeatSubmit(request)) {  
69.                         log.warn("please don't repeat submit,url:" + request.getServletPath());  
70.                         response.sendRedirect("/warn.html?code=repeatSubmitOrder&orgId="+request.getParameter("orgId"));  
71.                         return false;  
72.                     }  
73.                     removeRepeatToken(request,response);  
74.                 }  
75.             }  
76.             return true;  
77.         } else {  
78.             return super.preHandle(request, response, handler);  
79.         }  
80.     }  
81.   
82.     private boolean isRepeatSubmit(HttpServletRequest request) {  
83.         //从池子里面获取token  
84.         String serverToken = (String) request.getSession(true).getAttribute(SESSION_KEY_REPEATTOKEN_POOL);  
85.         if (serverToken == null||"###".equals(serverToken)) {  
86.             return true;  
87.         }  
88.         String clinetToken = request.getParameter(SESSION_KEY_REPEATTOKEN);//请求要素  
89.         if (StringUtil.isNullOrEmpty(clinetToken)) {  
90.             return true;  
91.         }  
92.         System.out.println("clinetToken:"+clinetToken);  
93.         if (!serverToken.contains(clinetToken)) {  
94.             return true;  
95.         }  
96.         return false;  
97.     }  
98. }