选用一个普通按钮，而不是提交按钮，用户点击按钮后，将其禁用。
将以下代码：
<input type="submit" value="Submit"/>


替换成：
<input type="button" value="Submit" οnclick="this.disabled=true; this.form.submit()"/>

发展到现在，基本上的javaweb应用都是前后端分离，在提交表单的时候，容易遇到网络延时或者是闪屏快速点击多次的情况，然后造成多个纪录的插入，这并不是我们想要的结果，鄙人有以下方法可以不同程度的防止重复提交：

1、前段控制，前端控制可以说是很多人的选择，因为简单，不需要考虑太多的其他因素，保障不会重复表单提交就好：比如：提交后把提交按钮设置为不可点击（disabled），或者设置子一个boolearn类型的值，依据值判断能否再次提交，再者可以使用promise

实现同步操作

2、后台校验：每一次操作者前，判断是否存在该数据（唯一值判断），如果存在则删除，反之新增

3、spring AOP 面向切面编程，过程：编写一个注解类（把注解卸载你调用的接口类方法上），和一个切面（切面切得就是这个注解类），切面的操作就是，设置指令（token+method：这个值必须保证唯一性）

上代码：


/**
 * @Author hhl
 * ToDo 防止重复提交注解类
 * @Date 2020/11/10 0010 18:39
 * @Version 1.0
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NoRepeatSubmit {
    /**
     * 设置请求锁定时间
     *
     * @return
     */
    int lockTime() default 10;
}


/**
 * @Author hhl
 * @Date 2020/11/10 0010 18:43
 * @Version 1.0
 */
@Service
public class RedisLock {

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 该加锁方法仅针对单实例 Redis 可实现分布式加锁
     * 对于 Redis 集群则无法使用
     *
     * 支持重复，线程安全
     *
     * @param lockKey   加锁键
     * @param clientId  加锁客户端唯一标识(采用UUID)
     * @param seconds   锁过期时间
     * @return
     */
    public boolean tryLock(String lockKey, String clientId, long seconds) {
        Object isExits = redisUtil.get(lockKey);
        if (Objects.isNull(isExits)) {
            redisUtil.set(lockKey, clientId, seconds);
            return true;
        } else {
            return false;
        }
    }

    /**
     * 与 tryLock 相对应，用作释放锁
     *
     * @param lockKey
     * @param clientId
     * @return
     */
    public boolean releaseLock(String lockKey, String clientId) {
        if (StringUtils.isNotBlank(lockKey) && StringUtils.isNotBlank(clientId) ) {
            redisUtil.remove(lockKey);
            return true;
        } else {
            return false;
        }
    }
}




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {
	@Autowired
    private RedisTemplate redisTemplate;
	/**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 获取缓存的过期时间
     */
    public long getExpire(final String key){
        return redisTemplate.getExpire(key);
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }

    /**
     * 哈希 添加 设置时效时间
     * @param key
     * @param hashKey
     * @param value
     * @param expireTime
     */
    public void hmSet(String key, Object hashKey, Object value, Long expireTime){
    	HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
    	hash.put(key,hashKey,value) ;
    	redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }

    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }

    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }

    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }

    /**
     * @Description: 获取自增长值
     * @param key key
     * @return
     */
    public  Long getIncr(String key) {
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        Long increment = entityIdCounter.getAndIncrement();
        entityIdCounter.expire(60*30, TimeUnit.SECONDS);
        return increment;
    }

    public  Long getIncr(String key, long timeOut) {
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        Long increment = entityIdCounter.getAndIncrement();
        entityIdCounter.expire(timeOut, TimeUnit.SECONDS);
        return increment;
    }

    public  Long getIncr(String key, long timeOut, TimeUnit timeUnit) {
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        Long increment = entityIdCounter.getAndIncrement();
        entityIdCounter.expire(timeOut, timeUnit);
        return increment;
    }

    /**
     * @Description: 初始化自增长值
     * @param key key
     * @param value 当前值
     */
    public void setIncr(String key, int value) {
        RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        counter.set(value);
        counter.expire(60*30, TimeUnit.SECONDS);
    }

    public void setIncr(String key, int value, long timeOut) {
        RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        counter.set(value);
        counter.expire(timeOut, TimeUnit.SECONDS);
    }

}


package com.zhirui.lmwy.project.norepeat;

import com.zhirui.core.model.ResultModel;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.servlet.http.HttpServletRequest;
import java.util.UUID;

/**
 * @Author hhl
 * @Date 2020/11/10 0010 18:41
 * @Version 1.0
 */
@Aspect
@Component
public class AspectSubmit {
    private static final Logger LOGGER = LoggerFactory.getLogger(AspectSubmit.class);

    @Autowired
    private RedisLock redisLock;

    @Pointcut("@annotation(noRepeatSubmit)")
    public void pointCut(NoRepeatSubmit noRepeatSubmit) {
    }

    @Around("pointCut(noRepeatSubmit)")
    public Object around(ProceedingJoinPoint pjp, NoRepeatSubmit noRepeatSubmit) throws Throwable {
        int lockSeconds = noRepeatSubmit.lockTime();

        HttpServletRequest request = RequestUtils.getRequest();
        Assert.notNull(request, "request can not null");

        // 此处可以用token或者JSessionId
        String token = request.getHeader("Authorization");
        String path = request.getServletPath();
        String key = getKey(token, path);
        String clientId = getClientId();

        boolean isSuccess = redisLock.tryLock(key, clientId, lockSeconds);
        LOGGER.info("tryLock key = [{}], clientId = [{}]", key, clientId);

        if (isSuccess) {
            LOGGER.info("tryLock success, key = [{}], clientId = [{}]", key, clientId);
            // 获取锁成功
            Object result;

            try {
                // 执行进程
                result = pjp.proceed();
            } finally {
                // 解锁
                redisLock.releaseLock(key, clientId);
                LOGGER.info("releaseLock success, key = [{}], clientId = [{}]", key, clientId);
            }

            return result;

        } else {
            // 获取锁失败，认为是重复提交的请求
            LOGGER.info("tryLock fail, key = [{}]", key + "重复请求，请稍后再试");
            return new ResultModel(true, "1", "重复请求，请稍后再试", null);
        }

    }

    private String getKey(String token, String path) {
        return token + path;
    }

    private String getClientId() {
        return UUID.randomUUID().toString();
    }
}


@RestController
@RequestMapping("/test")
@Slf4j
@Api(tags = "重复提交测试-api")
public class TestController {

    @Autowired
    private ProjectBuildService projectBuildService;

    @GetMapping("/norepeat")
    @NoRepeatSubmit(lockTime = 20000)
    public ResultModel norepeat() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ResultModel(true, ResultModel.CODE_SUCCESS, "查询成功");
    }
}

总结：三者可取其一，也可以1和3结合（推荐）

在项目开发中遇到多个表单需要提交到后台，而且其中包含一些table数据，所以最后经过查询资料总结出以下方法：（我用的前端框架是layui其他的思想应该是一样的）
在看代码之前先说一下我的思路，因为代码写的也不是很详细，

首先我们可以通过$("#countForm").serializeArray()得到序列化的form表单上的数据，但是这个数据不是标准后台可以接收的数据，所以需要通过我下面的那种手段给转换成标椎格式，就这样将页面上的每一个表单都转换成标准格式，然后将这些标准格式合并组合成为一个大的标准的json串，然后后台声明一个结构和这个json串一样的对象来接受这个json串，最后就实现了多个表单使用json数据格式传送数据，实际如果没有那些特殊的数据（table表数据、复选框数据等）直接用
$("#countForm").serialize()...."
var PolicyMainString=countFormData+'&'+numberFormData+'&'+writeFormData+'&'+sureFormData;"

这种方式就可以拼接成字符串传输到后台，但是没办法，需求就是这样的，为了实现功能只能麻烦一点，但是这种方式真的很实用，也通过这个项目学习到了更多解决问题的方法

以下是js代码
 		var countFormData = $("#countForm").serializeArray();
 		var numberFormData = $("#numberForm").serializeArray();
		var writeFormData = $("#writeForm").serializeArray();
		var sureFormData = $("#sureForm").serializeArray();
		//获取table数据
		var tr = $("#tableTest tr"); // 获取table中每一行内容
		var result = []; // 数组
		for (var i = 0; i < tr.length; i++) {// 遍历表格中每一行的内容
			var tds = $(tr[i]).find("td");
			if (tds.length > 0) {
				result.push({
					"affiliatedcompanyname" : $(tds[0]).find("input").val(),
					"companyaddress" : $(tds[1]).find("input").val(),
					"contact" : $(tds[2]).find("input").val(),
					"phone" : $(tds[3]).find("input").val()
				})	
			}
		}
		//************************以下的代码主要是讲序列化的json数据转换为标准格式的json数据串**********************************
		//获取countFormData表单数据
		var countObj={};//给obj分配内存
		for(var i =0;i<countFormData .length;i++){
			countObj[countFormData [i].name]=countFormData [i]['value'];
		}
		//获取countFormData表单中的附加险种
		var coveragecodeObj={};
       	var coveragecodelist = $("[name='coveragecode']:checked"),
       	coveragecode = '';
      	$.each(coveragecodelist,function (i,v){
      		coveragecode += i > 0 ? ","+v.value : v.value;
      		coveragecodeObj={coveragecode};
      	});
		//获取numberFormData表单数据
		var numberObj={};//给obj分配内存
		for(var i =0;i<numberFormData .length;i++){
			numberObj[numberFormData [i].name]=numberFormData [i]['value'];
		}
		//获取writeFormData表单数据
		var writeObj={};//给obj分配内存
		for(var i =0;i<writeFormData .length;i++){
			writeObj[writeFormData [i].name]=writeFormData [i]['value'];
		}
		//获取sureFormData表单数据
		var sureObj={};//给obj分配内存
		for(var i =0;i<sureFormData .length;i++){
			sureObj[sureFormData [i].name]=sureFormData [i]['value'];
		}
		//*******************************************************************************************************************
		var jsonData = { // json数据
				"businessList" : result,
				"countFormData": countObj,
				"numberFormData":numberObj,
				"writeFormData":writeObj,
				"sureFormData":sureObj,
				"coveragecodelist":coveragecodeObj
			}
       $.ajax({
			   type:"post",
			   url:contextPath+'policy/InsertPolicyMain',
			   contentType : "application/json;charset=UTF-8",
			   data:JSON.stringify(jsonData),
			   dataType:'JSON',
			   success:function(data){
				  if(true == data.status){
				        parent.layer.alert(data.promptMsg);
				  }
			}
		});

后台需要使用一个大的对象来接收这各json数据串（需要注意的是各个对象的名字需要和json串中的一样（小写的那个），不然接收不到）
import java.io.Serializable;
import java.util.List;

public class JsonData implements Serializable{
	private CoverageCodeList coveragecodelist;
	private CountFormData countFormData;
	private NumberFormData numberFormData;
	private WriteFormData writeFormData;
	private SureFormData sureFormData;
	private List<Business> businessList;
	//实现get和set方法
	//实现toString方法
	}

由于代码真的篇幅太大了，所以没有全部粘贴，只列出了一个大概，所以有问题的兄弟们多留言，看到一定第一时间回复，

现在想起来这个问题还是挺恶心的，为了不让大家再有同样的痛苦，故写成BLOG来分享。
首先介意大家能用AJAX提交就从项目开始用AJAX的方法提交。
当然我现在介绍的不是用AJAX方法，我就是用的普通struts2方法，现在看来非常简单，由以下几步组成：
一：在将要提交页面上加
<s:token />
它的作用是在每次生成页面生成一个唯一的信息令牌，也就是默认的拦截器能识别出来的；
二：在struts.xml中加：
  <interceptors>
   <interceptor name="authority" class="com.aircom.zzy.interceptor.AuthorityInterceptor"></interceptor>
    <interceptor-stack name="mydefault">
    <interceptor-ref name="token">
     <param name="includeMethods">roleAdd,roleUpd,moduleAdd,moduleUpd,add,upd</param>
    </interceptor-ref>
    <interceptor-ref name="defaultStack"></interceptor-ref>
   </interceptor-stack>
  </interceptors>
  <default-interceptor-ref name="mydefault"></default-interceptor-ref>
 
其中红色部分就是我要拦截的方法，当然是新增与修改了。把它这样写就不用每个都配置一次了。
 
        <action name="roleAdd" class="com.aircom.zzy.action.RoleAction" method="roleAdd">
            <result name="success" type="chain">roleList</result>
            <result name="invalid.token">/webadmin/pages/result.jsp?opt=roleList</result>
        </action>
 
这是对每一个方法的配置，有的人写了一个重复提交的页面来作为唯一跳转，但我认为那是不友好的，所以我用了一个页面中转，我的页面新增完了就到了列表页面，因此刷新时我还让它跳回列表页面，下面是我的中转页面result.jsp:
 
<%@ page language="java" pageEncoding="utf-8"%>
<%
 String opt = request.getParameter("opt") + ".action";
 %>
<script type="text/javascript">
 window.location.href = '<%=opt%>';
</script>
 
大家看见了吧，简单吧！这们定义方法拦截，不用在每个页面上都加<token />，只在需要的地方写需要的代码，大大减轻了我们的工作量和代码的复杂度，个人认为是可取的，如果大家有什么好的意见，可以贴出来，共同学习。