springmvc下的基于token的防重复提交实现

最新推荐文章于 2025-03-18 22:44:40 发布

搁浅forever

最新推荐文章于 2025-03-18 22:44:40 发布

阅读量3.2k

点赞数

分类专栏： springmvc

本文链接：https://blog.youkuaiyun.com/u011182715/article/details/51484427

版权

springmvc 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了如何在SpringMVC框架下利用Token机制解决注册等操作时因用户多次点击提交按钮导致的重复提交问题。通过配置拦截器，当请求页面时生成并存储Token，表单提交时验证Token，匹配成功则通过，否则阻止请求。使用Redis作为全局线程安全的存储介质，确保集群部署时的正确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述：

现在的网站在注册步骤中，由于后台要处理大量信息，造成响应变慢（测试机器性能差也是造成变慢的一个因素），在前端页面提交信息之前，等待后端响应，此时如果用户
再点一次提交按钮，后台会保存多份用户信息。为解决此问题，借鉴了struts2的token思路，在springmvc下实现token。

实现思路：

在springmvc配置文件中加入拦截器的配置，拦截两类请求，一类是到页面的，一类是提交表单的。当转到页面的请求到来时，生成token的名字和token值，一份放到redis缓存中，一份放传给页面表单的隐藏域。（注：这里之所以使用redis缓存，是因为tomcat服务器是集群部署的，要保证token的存储介质是全局线程安全的，而redis是单线程的）

当表单请求提交时，拦截器得到参数中的tokenName和token，然后到缓存中去取token值，如果能匹配上，请求就通过，不能匹配上就不通过。这里的tokenName生成时也是随机的，每次请求都不一样。而从缓存中取token值时，会立即将其删除（删与读是原子的，无线程安全问题）。

实现如下:

TokenInterceptor拦截器

public class TokenInterceptor implements HandlerInterceptor{
    private static Map<String,String> viewUrls=new HashMap<String,String>();
    private static Map<String,String> actionUrls=new HashMap<String,String>();
    private static Map<String,String> redisCacheClient = new HashMap<String,String>();//模拟redis缓存
    
    static
        viewUrls.put("/springmvc/regPage.action", "get");  //注册页面  /springmvc为我的项目名:http://localhost:8080/springmvc/regAction.action
        //如果你是直接通过localhost/regAction.action访问的话去掉/springmvc
              actionUrls.put("/springmvc/regAction.action", "post");//注册提交
    }
    
    {
        TokenHelper.setRedisCacheClient(redisCacheClient);
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
            Object handler) throws Exception {
        String requestURI=request.getRequestURI();
        String method = request.getMethod();
        //如果请求的是页面
        if(viewUrls.keySet().contains(requestURI) &&(viewUrls.get(requestURI)==null || viewUrls.get(requestURI).equalsIgnoreCase(method))){
               TokenHelper.setToken(request);
               return true;
        }else if(actionUrls.keySet().contains(requestURI) &&(actionUrls.get(requestURI)==null || actionUrls.get(requestURI).equalsIgnoreCase(method))){
          //如果是注册提交  
                  return handlerToke(request,response,handler);
        }

        return true;
    }
    
    private boolean handlerToke(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if(TokenHelper.validHandler(request)){
            return handlerValidToken(request,response,handler);
        }else{
            return handlerInvalid(request,response,handler);
        }        
    }

    private boolean handlerInvalid(HttpServletRequest request,
            HttpServletResponse response, Object handler) {
        try {
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("请不要重复提交！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                response.getWriter().close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    private boolean handlerValidToken(HttpServletRequest request,
            HttpServletResponse response, Object handler) {
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
            Object arg2, ModelAndView arg3) throws Exception {
        
    }

    
    @Override
    public void afterCompletion(HttpServletRequest arg0,
            HttpServletResponse arg1, Object arg2, Exception arg3)
            throws Exception {
        
    }

}
<pre name="code" class="java">TokenHelper.java

public class TokenHelper {
   private static Map<String,String> redisCacheClient = new HashMap<String,String>();//模拟redis缓存
    public static final String TOKEN_NAMESPACE = "com.tokens";
    public static final String TOKEN_NAME_FIELD = "tokenName";
    public static final String TOKEN__FIELD = "token";
    private static final Random RANDOM = new Random();



   public static void setToken(HttpServletRequest request) {
       String token = generateGUID();
       String tokenName = generateGUID();
       String redisTokenName = TOKEN_NAMESPACE+"."+tokenName;

       redisCacheClient.put(redisTokenName, token);

       request.setAttribute(TOKEN_NAME_FIELD, tokenName);//tokenName和token都要放到表单隐藏域中，tokenName的作用是用来区分不同的表单(不局限与注册页面)
       request.setAttribute(TOKEN__FIELD, token);
   }

   public static boolean validHandler(HttpServletRequest request) {
       String tokenName = getTokenName(request);
       String token = getToken(request,tokenName);

       if(tokenName!=null&&tokenName!=""){
           String redisToken = redisCacheClient.get(TOKEN_NAMESPACE+"."+tokenName);
           if(redisToken!=null&&redisToken!="" && redisToken!="null"){
               if(redisToken.endsWith(token)){
                   redisCacheClient.put(TOKEN_NAMESPACE+"."+tokenName, null);//从缓存中移除token
                   return true;
               }
           }
       }

       return false;
   }

   private static String getToken(HttpServletRequest request, String tokenName) {
       if(tokenName==null){
           return null;
       }
   //   Map<String, String[]> parameterMap = request.getParameterMap();
   //   String[] tokens = (String[]) (String[]) parameterMap.get(tokenName);
       String token = request.getParameter(tokenName);
       if(token==null||token==""){
           return null;

       }
       return token;
   }

   private static String getTokenName(HttpServletRequest request) {
       Map<String, String[]> parameterMap = request.getParameterMap();
       String[] names = parameterMap.get(TokenHelper.TOKEN_NAME_FIELD);
       if(names==null || names.length<1){
           return null;
       }
       return names[0];
   }

   public static String generateGUID()
    {
        return new BigInteger(165, RANDOM).toString(36).toUpperCase();
    }

   public static Map<String, String> getRedisCacheClient() {
       return redisCacheClient;
   }

   public static void setRedisCacheClient(Map<String, String> redisCacheClient) {
       TokenHelper.redisCacheClient = redisCacheClient;
   }

}

控制器:TokenController.java
@Controller
public class TokenController {

    @RequestMapping("/regPage.action")
    public String regPage(){
        return "reg";
    }
    
    @RequestMapping("/regAction.action")
    public ModelAndView regAction(String name,Model model){
        model.addAttribute("name", name);
        ModelAndView m = new ModelAndView();
        m.setViewName("/success");
        return m;
    }
}

注册页面:reg.jsp
<form action="/springmvc/regAction.action" method="post">

     <input type="hidden" name="${tokenName}" value="${token}"/>

    <input type="hidden" name="tokenName" value="${tokenName}"/>
    <input type="text" name="name">
    <input type="submit" value="提交">

</form>
success.jsp
success:${name}

springmvc.xml配置拦截器：
<mvc:interceptors>
    
    <bean class="com.yjp.interceptor.TokenInterceptor"/>
</mvc:interceptors>

测试结果:访问:http://localhost:8080/springmvc/regPage.action 提交表单后浏览器再后退再次提交表单提示请不要重复提交表单