防止表单重复提交

最新推荐文章于 2024-04-21 20:14:20 发布
最新推荐文章于 2024-04-21 20:14:20 发布
阅读量346 收藏 2
点赞数
分类专栏： 前端

防止表单重复提交的方法

一. 概述

我们在平时项目开发中可能会出现下面这些情况：

  1. 由于用户误操作，多次点击表单提交按钮。
  2. 由于网速等原因造成页面卡顿，用户重复刷新提交页面。
  3. 黑客或恶意用户使用postman等工具重复恶意提交表单（攻击网站）。

这些情况都会导致表单重复提交，造成数据重复。因此，我们需要对这些情况进行一定的预防。

二. 解决方案

1. 通过JavaScript防止表单重复提交

使用js防止表单重复提交的方式，其实就是设置一个全局的标记。在表单提交后，修改该标记的值。从而对重复提交进行预防。但是，并不推荐这种方式，该方法存在存在下列优缺点:

优点：

  • 简单，方便

缺点：

  • 如果客户端禁用JS，这种方法就会失效
  • 用户通过刷新页面方式，或使用postman等工具绕过前段页面仍能重复提交表单

代码示例：

<script type="text/javascript">
//默认提交状态为false
var commitStatus = false;
function submit(){
	if(commitStatus==false){
		//提交表单后，讲提交状态改为true
		commitStatus = true;
		return true;
	}else{
		return false;
	}
}
</script>

我们还可以在修改标记后， 设置提交按钮的禁用：

<script type="text/javascript">
//默认提交状态为false
var commitStatus = false;
function submit(){
	if(commitStatus==false){
		//提交表单后，讲提交状态改为true
		commitStatus = true;
		//设置disabed属性
   		 $("input[type='submit']").attr("disabled",true);
   		// 或者 $("input[type='submit']").attr("disabled","disabled");
   		// 移除disabed属性
   		//$("input[type='submit']").attr("disabled",false);
        //或者 $("input[type='submit']").attr("disabled","");
		return true;
	}else{
		return false;
	}
}
</script>
2. 在数据库里添加唯一约束

在数据库里添加唯一约束或创建唯一索引，防止出现重复数据。这是最有效的防止重复提交数据的方法。但是，通过数据库加唯一键约束能有效避免数据库重复插入相同数据。但无法阻止恶意用户重复提交表单（攻击网站），服务器大量执行sql插入语句，增加服务器和数据库负荷。

数据库加唯一性约束sql：

alter table tableName_xxx add unique key uniq_xxx(field1, field2)

service及时捕捉插入数据异常：

try {
	xxxMapper.insert(user);
} catch (DuplicateKeyException e) {
	logger.error("user already exist");
}
3. Redirect-After-Post模式

在提交后执行页面重定向，这就是所谓的Post-Redirect-Get (PRG)模式。简言之，当用户提交了表单后，你去执行一个客户端的重定向，转到提交成功信息页面。这能避免用户按F5导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。

(1). 用sendRedirect()函数转向

用户提交表单之后，执行重定向，转到成功信息页面。可避免用户按F5刷新页面和点击浏览器前进或后退导致的重复提交。

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException,IOException{
　 response.setContentType("text/html; charset=utf-8");
　 response.sendRedirect("/success.jsp");
}
(2). 用forward()函数转向

除此之外，当用户提交表单，服务器端调用forward()方法，转发到其他页面。

public void doPost(HttpServletRequest request, HttpServletResponse response) 
throws ServletException,IOException{
　 response.setContentType("text/html; charset=utf-8");
　 ServletContext sc = getServletContext();
　 sc.getRequestDispatcher("/success.jsp").forward(request, response);
}
4. 利用Session防止表单重复提交

在服务器端生成一个唯一的随机标识号，专业术语称为Token，同时在当前用户的Session域中保存这个Token。然后将Token发送到客户端的Form表单中，在Form表单中使用隐藏域来存储这个Token，表单提交的时候连同这个Token一起提交到服务器端，然后在服务器端判断客户端提交上来的Token与服务器端生成的Token是否一致，如果不一致，那就是重复提交了，此时服务器端就可以不处理重复提交的表单。如果相同则处理表单提交，处理完后清除当前用户的Session域中存储的标识号。

在下列情况下，服务器程序将拒绝处理用户提交的表单请求：

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

示例代码如下：

  1. 创建FormServlet，用于生成Token(令牌)和跳转到form.jsp页面
public class FormServlet extends HttpServlet {
    private static final long serialVersionUID = -884689940866074733L;
 
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        String token = UUID.randomUUID().toString();//创建令牌
        System.out.println("在FormServlet中生成的token："+token);
        request.getSession().setAttribute("token", token);  //在服务器使用session保存token(令牌)
        request.getRequestDispatcher("/form.jsp").forward(request, response);//跳转到form.jsp页面
    }
 
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
 
}
  1. 在form.jsp中使用隐藏域来存储Token(令牌)
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>form表单</title>
</head>
 
<body>
    <form action="${pageContext.request.contextPath}/servlet/DoFormServlet" method="post">
        <%--使用隐藏域存储生成的token--%>
        <%--
            <input type="hidden" name="token" value="<%=session.getAttribute("token") %>">
        --%>
        <%--使用EL表达式取出存储在session中的token--%>
        <input type="hidden" name="token" value="${token}"/> 
        用户名：<input type="text" name="username"> 
        <input type="submit" value="提交">
    </form>
</body>
</html>
  1. DoFormServlet处理表单提交
public class DoFormServlet extends HttpServlet {
 
    public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
 
            boolean b = isRepeatSubmit(request);//判断用户是否是重复提交
            if(b==true){
                System.out.println("请不要重复提交");
                return;
            }
            request.getSession().removeAttribute("token");//移除session中的token
            System.out.println("处理用户提交请求！！");
        }
        
        /**
         * 判断客户端提交上来的令牌和服务器端生成的令牌是否一致
         * @param request
         * @return 
         *         true 用户重复提交了表单 
         *         false 用户没有重复提交表单
         */
        private boolean isRepeatSubmit(HttpServletRequest request) {
            String client_token = request.getParameter("token");
            //1、如果用户提交的表单数据中没有token，则用户是重复提交了表单
            if(client_token==null){
                return true;
            }
            //取出存储在Session中的token
            String server_token = (String) request.getSession().getAttribute("token");
            //2、如果当前用户的Session中不存在Token(令牌)，则用户是重复提交了表单
            if(server_token==null){
                return true;
            }
            //3、存储在Session中的Token(令牌)与表单提交的Token(令牌)不同，则用户是重复提交了表单
            if(!client_token.equals(server_token)){
                return true;
            }
            
            return false;
        }
 
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
 
}
5. 使用AOP自定义切入实现

实现步骤：

  1. 自定义防止重复提交标记（@AvoidRepeatableCommit）。
  2. 对需要防止重复提交的Congtroller里的mapping方法加上该注解。
  3. 新增Aspect切入点，为@AvoidRepeatableCommit加入切入点。
  4. 每次提交表单时，Aspect都会保存当前key到reids（须设置过期时间）。
  5. 重复提交时Aspect会判断当前redis是否有该key，若有则拦截。

（1）自定义注解

import java.lang.annotation.*;
/**
 * 避免重复提交
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AvoidRepeatableCommit {

    /**
     * 指定时间内不可重复提交,单位毫秒
     * @return
     */
    long timeout()  default 30000 ;

}

（2）自定义切入点Aspect

/**
  * 重复提交aop
  */
@Aspect
@Component
public class AvoidRepeatableCommitAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * @param point
     */
    @Around("@annotation(com.xwolf.boot.annotation.AvoidRepeatableCommit)")
    public Object around(ProceedingJoinPoint point) throws Throwable {

        HttpServletRequest request  = ((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest();
        String ip = IPUtil.getIP(request);
        //获取注解
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        //目标类、方法
        String className = method.getDeclaringClass().getName();
        String name = method.getName();
        String ipKey = String.format("%s#%s",className,name);
        int hashCode = Math.abs(ipKey.hashCode());
        String key = String.format("%s_%d",ip,hashCode);
        log.info("ipKey={},hashCode={},key={}",ipKey,hashCode,key);
        AvoidRepeatableCommit avoidRepeatableCommit =  method.getAnnotation(AvoidRepeatableCommit.class);
        long timeout = avoidRepeatableCommit.timeout();
        if (timeout < 0){
            timeout = Constants.AVOID_REPEATABLE_TIMEOUT;
        }
        String value = (String) redisTemplate.opsForValue().get(key);
        if (StringUtils.isNotBlank(value)){
            return "请勿重复提交";
        }
        redisTemplate.opsForValue().set(key, UUIDUtil.uuid(),timeout,TimeUnit.MILLISECONDS);
        //执行方法
        Object object = point.proceed();
        return object;
    }

}
6. 使用Cookie对表单状态进行判断

以User（假设有一个user类）举例说明，将用户id和"ok" + id分别放到cookie里面，根据需要设置cookie存活时间，然后放到response里面。在每次提交form表单时，先判断cookie中的name是否是已经提交过的表单名称，如果是就重定向到error页面。

示例代码如下：

Cookie[] cookies = request.getCookies();
for (Cookie cookie : cookies) {
    if (String.valueOf(user.getId()).equals(cookie.getValue())) {
        response.sendRedirect("error.jsp");
    } else {
	Cookie cookie2 = new Cookie("ok" + user.getId(), String.valueOf(user.getId()));
	response.addCookie(cookie2);
    }
}

注意：如果客户端禁止了Cookie，该方法将不起任何作用，这点请注意。

7. 拦截器+注解方式
7.1 先自定义防止重复的注解
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 PreventRepeat {
}
7.2 自定义拦截器
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * 相同url和数据拦截器 为了防止重复提交等操作
 * 继承拦截器适配器
 */
public class SameUrlDataInterceptor extends HandlerInterceptorAdapter {

    /**
     * 覆盖父类的preHandle方法
     * 预处理回调方法，实现处理器的预处理,验证是否为重复提交，第三个参数为响应的处理器，自定义Controller
     * 返回值：true表示继续流程（如调用下一个拦截器或处理器）；false表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应；
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 1. 判断handler参数是否为HandlerMethod类的实例
        if (handler instanceof HandlerMethod) {

            // 2. 获取方法注解查看方式是否有PreventRepeat注解
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            PreventRepeat annotation = method.getAnnotation(PreventRepeat.class);
            if (annotation != null) {

                // 3. 调用重复数据验证方法
                boolean result = repeatDataValidator(request);
                if(result){
                    return false;
                }
                else{
                    return true;
                }

            }else{
                return true;
            }
        } else {

            // 4. 如果参数不是HandlerMethod类的实例则调用父类的preHandle方法
            return super.preHandle(request, response, handler);
        }
    }

    /**
     * 验证同一个url数据是否相同提交,相同返回true
     * @param httpServletRequest
     * @return
     */
    public boolean repeatDataValidator(HttpServletRequest httpServletRequest) throws Exception{

        try {

            // 1. 将请求参数转换为json字符串 需要在pom内引用jackson-databind
            ObjectMapper objectMapper = new ObjectMapper();
            String params = objectMapper.writeValueAsString(httpServletRequest.getParameterMap());

            // 2. 获取当前请求的url地址 并以url为key 参数为值存在map内
            String url=httpServletRequest.getRequestURI();
            Map<String,String> map=new HashMap(4);
            map.put(url, params);
            String nowUrlParams=map.toString();

            // 3. 获取session中上一次请求存储的url和参数字符串
            Object preUrlParams=httpServletRequest.getSession().getAttribute("oldUrlParams");

            // 4. 如果上一个数据为null,表示还没有访问页面 将当前方位的url和请求参数存储到session中
            if(preUrlParams == null) {
                httpServletRequest.getSession().setAttribute("oldUrlParams", nowUrlParams);
                return false;
            } else {

                // 5. 判断上一次访问的url和参数与本次是否相同 如相同则表示重复数据
                if(preUrlParams.toString().equals(nowUrlParams))
                {
                    return true;
                }
                else
                {
                    httpServletRequest.getSession().setAttribute("oldUrlParams", nowUrlParams);
                    return false;
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
            // 此处是我自定义异常
            throw new BusinessException("验证是否为重复请求时出错了！");
        }
    }
7.3 配置拦截器

xml：

<!-- 自定义相同url和数据的拦截器 拦截所有的url -->
<mvc:interceptors>
      <mvc:interceptor>
          <!-- 拦截url -->
          <mvc:mapping path="/**"/>
          <!-- 自定义拦截器类 -->
          <bean class="com.engraver.framework.interceptor.SameUrlDataInterceptor"/>
      </mvc:interceptor>
</mvc:interceptors>

springboot:

  1. 新建的 config 包，用来装初始化文件，在配置之下新建 WebConfigurer
  2. WebConfigurer需要实现 WebMvcConfigurer 这个接口，并实现里面的两个方法。（在老版本的 spring-boot 中使用的是WebMvcConfigurerAdapter，新版本中已过时！！！还有不能通过继承 WebMvcConfigurationSupport 这个类来实现，这样会在某些情况下失效！！！），第二个 addInterceptors 方法用来注册添加拦截器。
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@Configuration
public class WebConfigurer implements WebMvcConfigurer {
 
  // 这个方法是用来配置静态资源的，比如html，js，css，等等
  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
  }
 
  // 这个方法用来注册拦截器，我们自己写好的拦截器需要通过这里添加注册才能生效
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
  }
}
  1. 在WebConfigurer中添加拦截器
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@Configuration
public class WebConfigurer implements WebMvcConfigurer {
 
  @Autowired
  private SameUrlDataInterceptor sameUrlDataInterceptor ;
 
  // 这个方法是用来配置静态资源的，比如html，js，css，等等
  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
  }
 
  // 这个方法用来注册拦截器，我们自己写好的拦截器需要通过这里添加注册才能生效
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    // addPathPatterns("/**") 表示拦截所有的请求，
    // excludePathPatterns("/login", "/register") 表示除了登陆之外,都可以防止表单重复提交
    registry.addInterceptor(sameUrlDataInterceptor ).addPathPatterns("/**").excludePathPatterns("/login");
  }
}
  1. 使用方法
    在controller类的方法上增加@PreventRepeat注解

部分内容转自博客：
https://blog.csdn.net/Huozhiwu_11/article/details/78742886
https://www.cnblogs.com/huanghuizhou/p/9153837.html
https://blog.csdn.net/qq_30745307/article/details/80974407
https://www.jianshu.com/p/e8e51b3a9371

qq_36662478
关注
专栏目录
AOP防止表单重复提交
swagger_chao的博客
03-26 444
AOP防止表单重复提交 实现原理 基于HttpServletRequest获取服务端session 基于HttpServletRequest获取请求路径url 基于HttpServletRequest获取请求参数 java类适配实现自定义方法重写 通过检验url和对应的参数判断是否是同一次表单提交 自定义注解 @Inherited @Target(ElementType.METHOD) @Re...
使用struts2的token机制和cookie来防止表单重复提交
雨燕的博客
06-03 349
今天在做一个投票系统时要实现防止表单重复提交！ 当时就想到了用struts2提供的token机制 struts2的token机制防止表单重复提交： 首先需要在提交的jsp页面(要使用token机制，必须使用struts2提供的标签库)加上     这段代码，然后在struts.xml里面需要进行如下配置：   class=
Spring boot AOP 同步锁 防止表单重复提交(严格测试)
冯晓东——java,activiti
01-26 4016
Spring boot 利用AOP防止表单重复提交 表单重复提交，一直是软件架构的基础，现提供两种思路。 单块系统：利用Session机制实现。 分布式系统：利用redis缓存机制实现。 单块系统 实现思路: 表单加载后,通过ajax获取token,设置到session,并填写到表单hidden token中 表单提交时,携带token参数 利用aop拦截器校验是否携带此token 携带token...
JAVA AOP防止重复提交
刘骐毓的博客
01-13 726
通过Aop进行防止重复提交， 把pds-sessionId-请求路径作为请求的唯一key,用户发送请求时，判断key是否存在，如果存在则重复提交，不存在，则进行保存，执行完后或者出现异常进行清除。 key 超时5秒自动清除 一.自定义注解 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; imp...
防止表单重复提交的几种方法
wunianisme的博客
05-25 920
表单重复提交是在Web应用中经常遇到的一个比较麻烦的问题。有很多应用场景都会遇到重复提交问题，比如： 点击提交按钮两次。 点击刷新按钮。 使用浏览器后退按钮重复之前的操作，导致重复提交表单。 使用浏览器历史记录重复提交表单。 浏览器重复的HTTP请求。 用户提交表单时可能因为网速、网页被恶意刷新等原因，致使同一条记录重复插入到数据库中。我们可以从客户端和服务器端一起着手，设法避免同一表单的重复...
浅谈利用Session防止表单重复提交
08-28
浅谈利用Session防止表单重复提交 Session是Web应用程序中的一种机制，用于存储用户的会话信息。在Web应用程序中，表单重复提交是一个常见的问题，可能会导致数据库中产生冗余数据，浪费数据库资源。利用Session...
几种防止表单重复提交的方法
01-08
几种防止表单重复提交的方法 禁掉提交按钮。表单提交后使用Javascript使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题，如果客户端把Javascript给禁止掉，这种方法就无效了。 我之前的文章曾说...
springboot2.1+redis+拦截器 防止表单重复提交
10-05
在现代Web应用开发中，防止表单重复提交是一项重要的任务，因为这可能导致数据不一致性和服务器资源浪费。本文将深入探讨如何使用Spring Boot 2.1、Redis和拦截器来实现这一功能。以下是对这个主题的详细解释： ...
详解struts2的token机制和cookie来防止表单重复提交
01-20
详解struts2的token机制和cookie来防止表单重复提交 今天在做一个投票系统时要实现防止表单重复提交！ 当时就想到了用struts2提供的token机制 struts2的token机制防止表单重复提交： 首先需要在提交的jsp页面(要使用token机制，必须使用struts2提供的标签库)加上 <s></s>  这段代码，然后在struts.xml里面需要进行如下配置：  <action name=token class=com.xiaoluo.struts2.TokenAction> <result name=succ
js防止表单重复提交的两种方法
12-12
第一种：用flag标识，下面的代码设置... //当表单被提交过一次后checkSubmitFlg将变为true,根据判断将无法进行提交。 } checkSubmitFlg ==true; return true; } < /script > < form name=”form1” method=”pos
AOP 做接口防重复提交
ShiXZ213的博客
01-05 186
3 使用方法直接在方法前进行注解拦截。
使用AOP切面做防止用户重复提交功能
最新发布
qq_71416673的博客
04-21 491
关于如何做自定义注解，请看以下博客springboot做自定义校验注解这篇博客我们先跳过，直接来看实现// 缓存时间默认为10秒，请求完成自动清除，过期自动清除。
怎么防止重复提交?
RJ_0517b的博客
12-19 1230
1、禁掉提交按钮。表单提交后使用Javascript使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题，如果客户 端把Javascript给禁止掉，这种方法就无效了。 2、Post/Redirect/Get模式。在提交后执行页面重定向，这就是所谓的Post-Redirect-Get (PRG)模式。简言之，当用户提交了表 单后，你去执行一个客户端的重定向，转到提交成功信息页面。这能避免用户按F5导致的重复提交，而其也不会出现浏览器表 单重复提交的警告，也能消除按浏览器前进和后退按导致
防止表单重复提交的简单有效的策略
Leon_Jinhai_Sun的博客
02-27 301
点击提交按钮两次。 点击刷新按钮。 使用浏览器后退按钮重复之前的操作，导致重复提交表单。 使用浏览器历史记录重复提交表单。 浏览器重复的HTTP请求。 用户提交表单时可能因为网速的原因，或者网页被恶意刷新，致使同一条记录重复插入到数据库中，这是一个 比较棘手的问题。我们可以从客户端和服务器端一起着手，设法避免同一表单的重复提交。 1、js禁掉提交按钮。 表单提交后使用Javascript使...
使用Struts2的token机制和Cookie来防止表单重复提交
LeefengBoy的博客
10-02 1035
Struts2的token机制防止表单重复提交： 首先需要在提交的jsp页面(要使用token机制，必须使用struts2提供的标签库)加上    这段代码，然后在struts.xml里面需要进行如下配置： class="com.xiaoluo.struts2.TokenAction"> /tokenSuccess.jsp
一个AOP搞定表单重复提交问题
lzy_zhi_yuan的博客
06-01 277
一个AOP搞定表单重复提交问题
防止表单重复提交的策略
`saveToken`的目的是防止表单重复提交，因为每个新的表单提交都会有一个新的令牌。 然后，`doLogin`方法首先检查令牌的合法性，通过`isTokenValid(request)`方法。如果令牌无效（即表单被重复提交），则添加错误...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值