精华内容
下载资源
问答
  • java防止表单重复提交

    2021-04-05 14:37:48
    java防止表单重复提交方法一:方法二:提交一次后将按钮设为不可用 方法一: 方法二:提交一次后将按钮设为不可用 令牌生成器加密 将token存入Session中,转发到form表单 判断是否是重复提交 Form表单 ...


    在这里插入图片描述
    在这里插入图片描述

    方法一:

    在这里插入图片描述

    方法二:提交一次后将按钮设为不可用

    在这里插入图片描述

    令牌生成器加密
    在这里插入图片描述

    将token存入Session中,转发到form表单
    在这里插入图片描述

    判断是否是重复提交
    在这里插入图片描述

    Form表单
    在这里插入图片描述

    展开全文
  • Java防止表单重复提交

    千次阅读 2013-11-28 12:59:59
    看了网上的,有几种方法:  1 在你的表单页里HEAD区加入这段代码:        ...生成一个令牌保存在用户...中的令牌比较,如相同则是重复提交  3  在你的服务器端控件的代码中使用Response.Redirect("selfPa
    看了网上的,有几种方法: 
    1 在你的表单页里HEAD区加入这段代码: 
    <META HTTP-EQUIV="pragma" CONTENT="no-cache"> 
    <META HTTP-EQUIV="Cache-Control" CONTENT="no-cache, must-revalidate"> 
    <META HTTP-EQUIV="expires" CONTENT="Wed, 26 Feb 1997 08:21:57 GMT"> 

    生成一个令牌保存在用户session中,在form中加一个hidden域,显示该令 
    牌的值,form提交后重新生成一个新的令牌,将用户提交的令牌和session 
    中的令牌比较,如相同则是重复提交 

    在你的服务器端控件的代码中使用Response.Redirect("selfPage")语句。但是大多的数都不使用这种方法。 
    方法还有很多。。。 

    <input type="button" value="提交" οnclick="this.disabled=true;this.form.submit()"> 



    在JSP页面的FORM表单中添加一个hidden域   
      <input   type="hidden"   name="url"value=<%=request.getRequestURL()%>>   
        
      在你的serverlet中添加如下语句   
      String   url=request.getParameter("url");   
      response.sendRedirect(url);   
      我一般都是采用这样的方法返回JSP页面的,不太明白你说的重复刷新是什么概念   

    6 ajax 无刷新提交 

    7  Web开发中防止浏览器的刷新键引起系统操作重复提交 
    怎么解决呢?重定向可以解决页面刷新带来的数据的重复提交的问题,我们自然可以利用重定向的方式来解决这个问题。但是struts的action里面mapping.findword();跳转的话,默认的是在工程文件夹里面找要跳转的页面。这种情况,怎么解决呢? 
    修改struts-config.xml 文件, 在action里面有一个redirect重新定向的属性,struts中默认的是false,添加这个属性,改成true,在forword中写上要跳转页面的绝对或者相对地址就行了 
    修改如下: 
    <action-mappings> 
      <action attribute="newsActionForm" name="newsActionForm" 
       input="/addnews.jsp" path="/newsAction" parameter="method" 
       scope="request" type="com.yongtree.news.action.NewsAction"> 
       <forward name="list" path="/listnews.jsp" redirect="true"></forward> 
       <forward name="error" path="/addnews.jsp"></forward> 
      </action> 
    </action-mappings> 


    重复提交、重复刷新、防止后退的问题以及处理方式 

    一。前言 
    你在任何一个比较专业的BBS都会看到这样的问题,即使你Google一下,也会发现有很多的人在关注和询问,但大家给出的解决方法却都是千差万别,(有的人主张采用脚本来解决;有的则想重定向到别的页面;有的则将此问题提升到Token的角度)为什么会有如此大的差异呢? 

    二。问题场景 
    首先,我们应该先了解为什么要处理这样的问题?或者专业一点就是它适合的场景是什么?(似乎只有人来问没有人来解释) 

    1。重复提交、重复刷新的场景 
    重复提交、重复刷新都是来解决系统重复记录的问题。也就是说某个人在多次的提交某条记录(为什么?也许是闲了没有事情干的;最有可能是用户根本就不知道自己的提交结果是否已经执行了?!)。 

    但出现了这样的问题并不见得就必须处理,要看你所开发的系统的类别而定。比如你接手的是某个资源管理系统,系统本身从需求的角度根本就不允许出现"重复"的记录,在这样需求的约束条件下,去执行重复的提交动作只会引发“业务级异常”的产生,根本就不可能执行成功也就无所谓避免不避免的问题了。 



    2。防止后退的场景 
    了解了重复刷新、重复提交的场景,我们来了解一下"防止后退"操作的原因是什么?比如你在开发某个投票系统,它有很多的步骤,并且这些步骤之间是有联系的,比如第一步会将某些信息发送给第二步,第二步缓存了这些信息,同时将自身的信息发送给了第三步。。。。。等等,如果此时用户处在第三步骤下,我们想象一下某个淘气用户的用户点击了后退按钮,此时屏幕出现了第二步骤的页面,他再次的修改或者再次的提交,进入到下一个步骤(也就是第三步骤),错误就会在此产生?!什么错误呢?最为典型的就是这样的操作直接导致了对于第一个步骤信息的丢失!(如果这样的信息是依靠Request存放的话,当然你可以存放在Session或者更大的上下文环境中,但这不是个好主意!关于信息存放的问题,下次在就这个问题详细的讨论) 


    三。如何处理的问题 
    当然很多的系统(比如订票系统从需求上本身是允许个人重复订票的)是必须要避免重复刷新、重复提交、以及防止后退的问题的,但即使是这样的问题,也要区分如何处理以及在哪里处理的(网上只是告诉你如何处理,但很少去区分在哪里处理的),显然处理的方式无非是客户端或者服务器端两种,而面对不同的位置处理的方式也是不同的,但有一点要事先声明:任何客户端(尤其是B/S端)的处理都是不可信任的,最好的也是最应该的是服务器端的处理方法。 

    客户端处理: 
    面对客户端我们可以使用Javascript脚本来解决,如下 

    1。重复刷新、重复提交 
    Ways One:设置一个变量,只允许提交一次。 
    <script language="javascript"> 
        var checkSubmitFlg = false; 
        function checkSubmit() { 
          if (checkSubmitFlg == true) { 
             return false; 
          } 
          checkSubmitFlg = true; 
          return true; 
       } 
       document.ondblclick = function docondblclick() { 
        window.event.returnValue = false; 
       } 
       document.onclick = function doconclick() { 
           if (checkSubmitFlg) { 
             window.event.returnValue = false; 
           } 
       } 
    </script> 
    <html:form action="myAction.do" method="post" οnsubmit="return checkSubmit();"> 

    Way Two : 将提交按钮或者image置为disable 
      <html:form action="myAction.do" method="post"  
        οnsubmit="getElById('submitInput').disabled = true; return true;">   
      <html:image styleId="submitInput" src="images/ok_b.gif" border="0" /> 
      </html:form>  

    2。防止用户后退 
    这里的方法是千姿百态,有的是更改浏览器的历史纪录的,比如使用window.history.forward()方法;有的是“用新页面的URL替换当前的历史纪录,这样浏览历史记录中就只有一个页面,后退按钮永远不会变为可用。”比如使用javascript:location.replace(this.href); event.returnValue=false; 


    2.服务器端的处理(这里只说Struts框架的处理) 
    利用同步令牌(Token)机制来解决Web应用中重复提交的问题,Struts也给出了一个参考实现。 

    基本原理: 
    服务器端在处理到达的请求之前,会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较, 
    看是否匹配。在处理完该请求后,且在答复发送给客户端之前,将会产生一个新的令牌,该令牌除传给 
    客户端以外,也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次 
    提交的话,客户端传过来的令牌就和服务器端的令牌不一致,从而有效地防止了重复提交的发生。 

    if (isTokenValid(request, true)) { 
        // your code here 
        return mapping.findForward("success"); 
    } else { 
        saveToken(request); 
        return mapping.findForward("submitagain"); 


    Struts根据用户会话ID和当前系统时间来生成一个唯一(对于每个会话)令牌的,具体实现可以参考 
    TokenProcessor类中的generateToken()方法。 

    1. //验证事务控制令牌,<html:form >会自动根据session中标识生成一个隐含input代表令牌,防止两次提交 
    2. 在action中: 


           //<input type="hidden" name="org.apache.struts.taglib.html.TOKEN"  
           //  value="6aa35341f25184fd996c4c918255c3ae"> 
           if (!isTokenValid(request)) 
               errors.add(ActionErrors.GLOBAL_ERROR, 
                          new ActionError("error.transaction.token")); 
           resetToken(request); //删除session中的令牌 

    3. action有这样的一个方法生成令牌 
       protected String generateToken(HttpServletRequest request) { 
           HttpSession session = request.getSession(); 
           try { 
               byte id[] = session.getId().getBytes(); 
               byte now[] = 
                   new Long(System.currentTimeMillis()).toString().getBytes(); 
               MessageDigest md = MessageDigest.getInstance("MD5"); 
               md.update(id); 
               md.update(now); 
               return (toHex(md.digest())); 
           } catch (IllegalStateException e) { 
               return (null); 
           } catch (NoSuchAlgorithmException e) { 
               return (null); 
           } 
       }  

    总结 
    对于重复提交、重复刷新、防止后退等等都是属于系统为避免重复记录而需要解决的问题,在客户端去处理需要针对每一种的可能提出相应的解决方案,然而在服务器端看来只不过是对于数据真实性的检验问题,基于令牌的处理就是一劳永逸的方法。 

    同时我们也看到,从不同的角度去看待问题,其解决的方法也是不同的。客户端更追求的是用户的操作,而服务端则将注意力放在了数据的处理上,所以在某个对于服务器端看似容易的问题上,用客户端来解决却麻烦了很多!反之依然。所以在某些问题的处理上我们需要综合考虑和平衡,是用客户端来解决?还是用服务器端来处理?
    展开全文
  • 前言:记得刚学java web时,老师说过用redirect重定向能防止表单提交。但是真正做项目时发现也不尽如意,自己一般还是用js控制表单的提交. 最近看了这篇文章也颇受启发,尤其是下面的关于“集群”评论部分.虽然...

    前言:记得刚学java web时,老师说过用redirect重定向能防止表单提交。但是真正做项目时发现也不尽如意,自己一般还是用js控制表单的提交.

    最近看了这篇文章也颇受启发,尤其是下面的关于“集群”评论部分.虽然听说过集群,但是从看来没有真正的想深入了解过。通过这篇文章,我的书单里又增加了

    2本书。微笑

    在平时开发中,如果网速比较慢的情况下,用户提交表单后,发现服务器半天都没有响应,那么用户可能会以为是自己没有提交表单,就会再点击提交按钮重复提交表单,我们在开发中必须防止表单重复提交。

    一、表单重复提交的常见应用场景

    有如下的form.jsp页面

    复制代码
     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <!DOCTYPE HTML>
     3 <html>
     4   <head>
     5     <title>Form表单</title>
     6   </head>
     7   
     8   <body>
     9       <form action="${pageContext.request.contextPath}/servlet/DoFormServlet" method="post">
    10         用户名:<input type="text" name="username">
    11         <input type="submit" value="提交" id="submit">
    12     </form>
    13   </body>
    14 </html>
    复制代码

      form表单提交到DoFormServlet进行处理

    复制代码
     1 package xdp.gacl.session;
     2 
     3 import java.io.IOException;
     4 import javax.servlet.ServletException;
     5 import javax.servlet.http.HttpServlet;
     6 import javax.servlet.http.HttpServletRequest;
     7 import javax.servlet.http.HttpServletResponse;
     8 
     9 public class DoFormServlet extends HttpServlet {
    10 
    11     public void doGet(HttpServletRequest request, HttpServletResponse response)
    12             throws ServletException, IOException {
    13         //客户端是以UTF-8编码传输数据到服务器端的,所以需要设置服务器端以UTF-8的编码进行接收,否则对于中文数据就会产生乱码
    14         request.setCharacterEncoding("UTF-8");
    15         String userName = request.getParameter("username");
    16         try {
    17             //让当前的线程睡眠3秒钟,模拟网络延迟而导致表单重复提交的现象
    18             Thread.sleep(3*1000);
    19         } catch (InterruptedException e) {
    20             e.printStackTrace();
    21         }
    22         System.out.println("向数据库中插入数据:"+userName);
    23     }
    24 
    25     public void doPost(HttpServletRequest request, HttpServletResponse response)
    26             throws ServletException, IOException {
    27         doGet(request, response);
    28     }
    29 
    30 }
    复制代码

      如果没有进行form表单重复提交处理,那么在网络延迟的情况下下面的操作将会导致form表单重复提交多次

    1.1、场景一:在网络延迟的情况下让用户有时间点击多次submit按钮导致表单重复提交

      演示动画如下所示:

     1.2、场景二:表单提交后用户点击【刷新】按钮导致表单重复提交

    演示动画如下所示:

      点击浏览器的刷新按钮,就是把浏览器上次做的事情再做一次,因为这样也会导致表单重复提交。

    1.3、场景三:用户提交表单后,点击浏览器的【后退】按钮回退到表单页面后进行再次提交

    演示动画如下所示:

    二、利用JavaScript防止表单重复提交

      既然存在上述所说的表单重复提交问题,那么我们就要想办法解决,比较常用的方法是采用JavaScript来防止表单重复提交,具体做法如下:

    修改form.jsp页面,添加如下的JavaScript代码来防止表单重复提交

    复制代码
     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <!DOCTYPE HTML>
     3 <html>
     4   <head>
     5     <title>Form表单</title>
     6         <script type="text/javascript">
     7         var isCommitted = false;//表单是否已经提交标识,默认为false
     8         function dosubmit(){
     9             if(isCommitted==false){
    10                 isCommitted = true;//提交表单后,将表单是否已经提交标识设置为true
    11                 return true;//返回true让表单正常提交
    12             }else{
    13                 return false;//返回false那么表单将不提交
    14             }
    15         }
    16     </script>
    17   </head>
    18   
    19   <body>
    20       <form action="${pageContext.request.contextPath}/servlet/DoFormServlet" onsubmit="return dosubmit()" method="post">
    21         用户名:<input type="text" name="username">
    22         <input type="submit" value="提交" id="submit">
    23     </form>
    24   </body>
    25 </html>
    复制代码

      我们看看使用了JavaScript来防止表单提交重复是否可以成功,运行效果如下:

      可以看到,针对"在网络延迟的情况下让用户有时间点击多次submit按钮导致表单重复提交"这个应用场景,使用JavaScript是可以解决这个问题的,解决的做法就是"用JavaScript控制Form表单只能提交一次"。

      除了用这种方式之外,经常见的另一种方式就是表单提交之后,将提交按钮设置为不可用,让用户没有机会点击第二次提交按钮,代码如下:

    复制代码
    1 function dosubmit(){
    2     //获取表单提交按钮
    3     var btnSubmit = document.getElementById("submit");
    4     //将表单提交按钮设置为不可用,这样就可以避免用户再次点击提交按钮
    5     btnSubmit.disabled= "disabled";
    6     //返回true让表单可以正常提交
    7     return true;
    8 }
    复制代码

    运行效果如下:

       另外还有一种做法就是提交表单后,将提交按钮隐藏起来,这种做法和将提交按钮设置为不可用是差不多的,个人觉得将提交按钮隐藏影响到页面布局的美观,并且可能会让用户误以为是bug(怎么我一点击按钮,按钮就不见了呢?用户可能会有这样的疑问),我个人在开发中用得比较多的是表单提交后,将提交按钮设置为不可用,反正使用JavaScript防止表单重复提交的做法都是差不多的,目的都是让表单只能提交一次,这样就可以做到表单不重复提交了。

      使用JavaScript防止表单重复提交的做法只对上述提交到导致表单重复提交的三种场景中的【场景一】有效,而对于【场景二】和【场景三】是没有用,依然无法解决表单重复提交问题。

    三、利用Session防止表单重复提交

      对于【场景二】和【场景三】导致表单重复提交的问题,既然客户端无法解决,那么就在服务器端解决,在服务器端解决就需要用到session了。

      具体的做法:在服务器端生成一个唯一的随机标识号,专业术语称为Token(令牌),同时在当前用户的Session域中保存这个Token。然后将Token发送到客户端的Form表单中,在Form表单中使用隐藏域来存储这个Token,表单提交的时候连同这个Token一起提交到服务器端,然后在服务器端判断客户端提交上来的Token与服务器端生成的Token是否一致,如果不一致,那就是重复提交了,此时服务器端就可以不处理重复提交的表单。如果相同则处理表单提交,处理完后清除当前用户的Session域中存储的标识号。
      在下列情况下,服务器程序将拒绝处理用户提交的表单请求:

    1. 存储Session域中的Token(令牌)与表单提交的Token(令牌)不同。
    2. 当前用户的Session中不存在Token(令牌)
    3. 用户提交的表单数据中没有Token(令牌)

    看具体的范例:

      1.创建FormServlet,用于生成Token(令牌)和跳转到form.jsp页面

    复制代码
     1 package xdp.gacl.session;
     2 
     3 import java.io.IOException;
     4 import javax.servlet.ServletException;
     5 import javax.servlet.http.HttpServlet;
     6 import javax.servlet.http.HttpServletRequest;
     7 import javax.servlet.http.HttpServletResponse;
     8 
     9 public class FormServlet extends HttpServlet {
    10     private static final long serialVersionUID = -884689940866074733L;
    11 
    12     public void doGet(HttpServletRequest request, HttpServletResponse response)
    13             throws ServletException, IOException {
    14 
    15         String token = TokenProccessor.getInstance().makeToken();//创建令牌
    16         System.out.println("在FormServlet中生成的token:"+token);
    17         request.getSession().setAttribute("token", token);  //在服务器使用session保存token(令牌)
    18         request.getRequestDispatcher("/form.jsp").forward(request, response);//跳转到form.jsp页面
    19     }
    20 
    21     public void doPost(HttpServletRequest request, HttpServletResponse response)
    22             throws ServletException, IOException {
    23         doGet(request, response);
    24     }
    25 
    26 }
    复制代码

      2.在form.jsp中使用隐藏域来存储Token(令牌)

    复制代码
     1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
     2 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     3 <html>
     4 <head>
     5 <title>form表单</title>
     6 </head>
     7 
     8 <body>
     9     <form action="${pageContext.request.contextPath}/servlet/DoFormServlet" method="post">
    10         <%--使用隐藏域存储生成的token--%>
    11         <%--
    12             <input type="hidden" name="token" value="<%=session.getAttribute("token") %>">
    13         --%>
    14         <%--使用EL表达式取出存储在session中的token--%>
    15         <input type="hidden" name="token" value="${token}"/> 
    16         用户名:<input type="text" name="username"> 
    17         <input type="submit" value="提交">
    18     </form>
    19 </body>
    20 </html>
    复制代码

      3.DoFormServlet处理表单提交

    复制代码
     1 package xdp.gacl.session;
     2 
     3 import java.io.IOException;
     4 import javax.servlet.ServletException;
     5 import javax.servlet.http.HttpServlet;
     6 import javax.servlet.http.HttpServletRequest;
     7 import javax.servlet.http.HttpServletResponse;
     8 
     9 public class DoFormServlet extends HttpServlet {
    10 
    11     public void doGet(HttpServletRequest request, HttpServletResponse response)
    12                 throws ServletException, IOException {
    13 
    14             boolean b = isRepeatSubmit(request);//判断用户是否是重复提交
    15             if(b==true){
    16                 System.out.println("请不要重复提交");
    17                 return;
    18             }
    19             request.getSession().removeAttribute("token");//移除session中的token
    20             System.out.println("处理用户提交请求!!");
    21         }
    22         
    23         /**
    24          * 判断客户端提交上来的令牌和服务器端生成的令牌是否一致
    25          * @param request
    26          * @return 
    27          *         true 用户重复提交了表单 
    28          *         false 用户没有重复提交表单
    29          */
    30         private boolean isRepeatSubmit(HttpServletRequest request) {
    31             String client_token = request.getParameter("token");
    32             //1、如果用户提交的表单数据中没有token,则用户是重复提交了表单
    33             if(client_token==null){
    34                 return true;
    35             }
    36             //取出存储在Session中的token
    37             String server_token = (String) request.getSession().getAttribute("token");
    38             //2、如果当前用户的Session中不存在Token(令牌),则用户是重复提交了表单
    39             if(server_token==null){
    40                 return true;
    41             }
    42             //3、存储在Session中的Token(令牌)与表单提交的Token(令牌)不同,则用户是重复提交了表单
    43             if(!client_token.equals(server_token)){
    44                 return true;
    45             }
    46             
    47             return false;
    48         }
    49 
    50     public void doPost(HttpServletRequest request, HttpServletResponse response)
    51             throws ServletException, IOException {
    52         doGet(request, response);
    53     }
    54 
    55 }
    复制代码

      生成Token的工具类TokenProccessor

    复制代码
     1 package xdp.gacl.session;
     2 
     3 import java.security.MessageDigest;
     4 import java.security.NoSuchAlgorithmException;
     5 import java.util.Random;
     6 import sun.misc.BASE64Encoder;
     7 
     8 public class TokenProccessor {
     9 
    10     /*
    11      *单例设计模式(保证类的对象在内存中只有一个)
    12      *1、把类的构造函数私有
    13      *2、自己创建一个类的对象
    14      *3、对外提供一个公共的方法,返回类的对象
    15      */
    16     private TokenProccessor(){}
    17     
    18     private static final TokenProccessor instance = new TokenProccessor();
    19     
    20     /**
    21      * 返回类的对象
    22      * @return
    23      */
    24     public static TokenProccessor getInstance(){
    25         return instance;
    26     }
    27     
    28     /**
    29      * 生成Token
    30      * Token:Nv6RRuGEVvmGjB+jimI/gw==
    31      * @return
    32      */
    33     public String makeToken(){  //checkException
    34         //  7346734837483  834u938493493849384  43434384
    35         String token = (System.currentTimeMillis() + new Random().nextInt(999999999)) + "";
    36         //数据指纹   128位长   16个字节  md5
    37         try {
    38             MessageDigest md = MessageDigest.getInstance("md5");
    39             byte md5[] =  md.digest(token.getBytes());
    40             //base64编码--任意二进制编码明文字符   adfsdfsdfsf
    41             BASE64Encoder encoder = new BASE64Encoder();
    42             return encoder.encode(md5);
    43         } catch (NoSuchAlgorithmException e) {
    44             throw new RuntimeException(e);
    45         }
    46     }
    47 }
    复制代码

      首先访问FormServlet,在FormServlet中生成Token之后再重定向到form.jsp页面,这次是在服务器端处理表单重复提交的,运行效果如下:

      从运行效果中可以看到,通过这种方式处理表单重复提交,可以解决上述的场景二和场景三中出现的表单重复提交问题。

    转:http://www.cnblogs.com/xdp-gacl/p/3859416.html


    展开全文
  • 防止表单重复提交,或者是防止按F5 刷新提交表单。  在WEB开发中是经常会碰到这样的问题的。  目前主流的解决方法有以下三种:  1、采用脚本来解决  2、重定向到别的页面  3、使用s:token 标签 ...

    防止表单重复提交,或者是防止按F5 刷新提交表单。

           在WEB开发中是经常会碰到这样的问题的。

       目前主流的解决方法有以下三种:

        1、采用脚本来解决

        2、重定向到别的页面

        3、使用s:token 标签

       

       由于我是使用S2SH来开发的,所以就选择了第三种方法。

         先简单的解释下<s:token  /> 这个标签,<s:token>就是为了防止Struts2中表单重复提交的。他的实现类是org.apache.struts2.views.jsp.ui.TokenTag,继承于org.apache.struts2.views.jsp.ComponentTagSupport。

    TokenTag ComponentTagSupport.doStartTag 将控件对象化
    TokenTag ComponentTagSupport.doEndTag component.end 调用component(Token)
    Token 继承自org.apache.struts2.components.UIBean,因此首先调用UIBean.end方法,在UIBean.end方法中最后一句调用定义为protected的方法evaluateExtraParams,这个方法是提供给UIBean的子类扩展使用的,在Token的evaluateExtraParams方法中
    String token = buildToken(tokenName);
    其中buildToken方法实际上调用的是 TokenHelper.setToken方法,在setToken方法中值得注意的是两点,
    1、 generateGUID()方法,此方法是生成Token值得算法所在
    2 、session.put(tokenName, token)可以看到此处将生成的值存储在session中,等待以后比对。

    生成guid后,token拦截器会判断客户端form提交的token和session中保存的session是否equals。如果equals则执行Action。否则拦截器直接返回invaid.token结果,Action对应的方法也不会执行

     所以我解决的方法是:

       1、前台jsp 表单在提交(</form>)之前,加入<s:token />标签,action中不需要做修改。

       2、在配置文件中做如下的配置就可以了

      

    [java] view plaincopy
    1. <action name="generateChoose" class="com.fzdna.application.agent.actions.admin.manager.numberManager.ChooseNumberAction"  
    2.             method="generateChoose">   
    3.             <interceptor-ref name="defaultStack" />    
    4.             <interceptor-ref name="token" />    
    5.             <result name="success">/admin/manager/numberManager/generateChooseNumber.jsp</result>  
    6.             <result name="error">/admin/manager/numberManager/generateChooseNumber.jsp</result>  
    7.             <result name="invalid.token" type="redirect">generateChooseNumber.do</result>  
    8.          </action>  

     这样就可以防止表单重复提交。

     

       再简单说下采用脚本控制,这中方式本来就存在缺陷,如果客服端禁止使用脚本,即使你的脚本写的再好,也是白费。个人建议还是在服务器端进行控制。

      前台jsp页面:

      <form action="duplicateAction.do" method="post" οnsubmit="return checkSubmit();"></form>

     js 代码如下:

      

    [javascript] view plaincopy
    1. <mce:script language="javascript"><!--  
    2.       
    3.     var checkSubmitFlag = false;      
    4.     function checkSubmit() {      
    5.       if (checkSubmitFlag == true) {      
    6.          return false;      
    7.       }      
    8.       checkSubmitFlag = true;      
    9.       return true;      
    10.    }      
    11.    document.ondblclick = function docondblclick() {      
    12.     window.event.returnValue = false;      
    13.    }      
    14.    document.onclick = function doconclick() {      
    15.        if (checkSubmitFlag) {      
    16.          window.event.returnValue = false;      
    17.        }      
    18.    }      
    19. // --></mce:script>   
      

     

    至于跳到中转页面,也就是在表单提交的时候跳转到一个中转的jsp页面即可。

    借助于网上达人的意见,及个人的体会,简单总结下。

    展开全文
  • 我们大家再进行web开发的时候,必不可少会遇见表单重复提交问题。今天就来给总结如何解决表单提交问题,欢迎大家交流指正。 首先我们在讨论如何解决表单重复提交问题之前先来解决三个问题:1.什么叫表单重复提交?...
  • 防止表单重复提交的处理步骤: 1、在跳转到表单之前生成一个不易重复的字符串Token,放入到session中,再跳转到表单页面 2、在form表单中,使用隐藏域 获取后台生成的Token,在提交表单时一起提交到后台 ...
  • java防止表单重复提交后退等

    千次阅读 2012-09-20 16:13:13
    1 在你的表单页里HEAD区加入这段代码: 2 生成一个令牌保存在用户session...中的令牌比较,如相同则是重复提交 3 在你的服务器端控件的代码中使用Response.Redirect("selfPage")语句。但是大多的数都不
  • java实现防止表单重复提交

    热门讨论 2010-07-19 10:46:14
    服务器端避免表单重复提交,利用同步令牌来解决重复提交的基本原理如下:(1)用户访问提交数据的页面,服务器端在这次会话中,创建一个session对象,并产生一个令牌值,将这个令牌值作为隐藏输入域的值,随表单一起发送到...
  • 在平时开发中,如果网速比较慢的情况下,用户提交表单后,发现服务器半天都没有响应,那么用户可能会以为是自己没有提交表单,就会再点击提交按钮重复提交表单,我们在开发中必须防止表单重复提交。 一、表单重复...
  • java web 防止表单重复提交解决方案

    千次阅读 2015-12-05 10:48:25
    在平时开发中,如果网速比较慢的情况下,用户提交表单后,发现服务器半天都没有响应,那么用户可能会以为是自己没有提交表单,就会再点击提交按钮重复提交表单,我们在开发中必须防止表单重复提交。 一、表单重复...
  • 主要介绍了JAVA防止重复提交Web表单的方法,涉及Java针对表单的相关处理技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • JAVA Web防止表单重复提交实例

    千次阅读 2013-09-21 09:27:09
    防止表单重复提交,解决实际问题
  • Java 使用Token令牌防止表单重复提交

    万次阅读 2016-03-23 10:11:13
    Java 使用Token令牌防止表单重复提交的步骤: - 在服务器端生成一个唯一的随机标识号,专业术语称为Token(令牌),同时在当前用户的Session域中保存这个Token。 - 将Token发送到客户端的Form表单中,在Form表单中...
  • 表单重复提交的问题可能大多数开发者都会遇到,之前的解决方案是在进入提交表单页面,将验证码保存在session中,当表单提交时,就会验证 验证码是否存在,如果存在,则删除,通过 验证,如果不存在,则提示重复提交...
  • Java Web防止表单重复提交

    千次阅读 2016-04-26 20:21:43
    上述三种情况都会导致表单数据的重复提交,这样直接的后果便是服务器的多次响应,这当然不是我们程序猿想看到的。好了,我要开始装X模式了,先搭建相关开发环境,一个登陆页面login.jsp,一个login.action,一个...
  • 几种防止表单重复提交的方法  1.禁掉提交按钮。表单提交后使用Javascript使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题,如果客户端把Javascript给禁止掉,这种方法就无效了。  我...
  • 防止表单重复提交

    2019-01-22 14:32:03
    在平时开发中,如果网速比较慢的情况下,用户提交表单后,发现服务器半天都没有响应,那么用户可能会以为是自己没有提交表单,就会再点击提交按钮重复提交表单,我们在开发中必须防止表单重复提交。 一、表单重复...
  • Java语言防止表单重复提交token机制

    千次阅读 2018-08-07 17:10:53
    也叫做令牌机制,除了重定向以外的另一种处理表单重复提交的方法 login.jsp================================================ <div align="center"> <h1>令牌机制</h1> ...
  • 主要介绍了浅谈利用Session防止表单重复提交,简单介绍表单重复提交的情况,分析,以及解决方法代码示例,具有一定借鉴价值,需要的朋友可以了解下。
  • 一、简介 最近在项目中,有一个用户移动端打卡上班的功能,如果短时间内快速双击几次打卡按钮的话,数据库会生成几条一模一样的打卡记录,很明显这...因此有效防止表单重复提交有一定的必要性。 二、解决方案 一般
  • javascript方式防止表单重复提交

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,706
精华内容 7,082
关键字:

java防止表单重复提交

java 订阅