前言

在系统中，有些接口如果重复提交，可能会造成脏数据或者其他的严重的问题，所以我们一般会对与数据库有交互的接口进行重复处理

首先可以在前端做一层控制。当前端触发操作时，或弹出确认界面，或 disable 禁用按钮等等，但是这并不能彻底解决问题。假设我们不是从客户端提交，而是被其他的系统调用，还会遇到这种问题
为了彻底解决问题，还需要在后端对接口做防重处理

一般会引起表单重复提交的场景

在网络延迟的情况下让用户有时间点击多次 submit 按钮导致表单重复提交
表单提交后用户点击【刷新】按钮导致表单重复提交
用户提交表单后，点击浏览器的【后退】按钮回退到表单页面后进行再次提交

防止表单重复提交

单机

实现的思路步骤

通过当前用户上一次请求的 url 和参数，验证是否是重复的请求

拦截器拦截请求，将上一次请求的 url 和参数和这次的对比
判断，是否一致说明重复提交并记录日志

代码实现

创建自定义注解

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

}

创建自定义拦截器

public class SameUrlDataInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            // 是否有 SameUrlData 注解
            SameUrlData annotation = method.getAnnotation(SameUrlData.class);
            if (annotation != null) {
            	// 如果重复相同数据
                if (repeatDataValidator(request)) {
                    response.sendRedirect("/error/409");
                    return false;
                } else {
                    return true;
                }
            }
            return true;
        } else {
            return super.preHandle(request, response, handler);
        }
    }

    /**
     * 验证同一个url数据是否相同提交，相同返回true
     */
    private boolean repeatDataValidator(HttpServletRequest httpServletRequest) {
        String params = JsonMapper.toJsonString(httpServletRequest.getParameterMap());
        String url = httpServletRequest.getRequestURI();
        Map<String, String> map = new HashMap<>();
        map.put(url, params);
        String nowUrlParams = map.toString();

        Object preUrlParams = httpServletRequest.getSession().getAttribute("repeatData");
        // 如果上一个数据为null，表示没有重复提交
        if (preUrlParams == null) { 
            httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);
            return false;
        // 否则，已经有过提交了
        } else { 
        	// 如果上次url+数据 和 本次url+数据相同，则表示重复添加数据
            if (preUrlParams.toString().equals(nowUrlParams)) { 
                return true;
            // 如果上次 url+数据 和 本次url加数据不同，则不是重复提交
            } else { 
                httpServletRequest.getSession().setAttribute("repeatData", nowUrlParams);
                return false;
            }
        }
    }
}

将自定义拦截器添加到容器

<mvc:interceptor>
	<mvc:mapping path="/**"/>
	<bean class="com.chinagdn.base.common.interceptor.SameUrlDataInterceptor"/>
</mvc:interceptor>

controller 层

@Controller
public class TestController {

	// 在 controller 层使用 @SameUrlData 注解即可
	@SameUrlData
	@RequestMapping(value = "save", method = RequestMethod.POST)
	public String save(@Valid LoginUser loginUser, Errors errors, RedirectAttributes redirectAttributes, Model model) throws Exception {

		//.....
	}
}

分布式

在这里插入图片描述
很显然在分布式的情况下，使用上述方法已无法防止表单重复提交了；一者在分布式部署下 session 是不共享的，二者使用 上一次请求的 url 和参数和这次的对比 已无法对比请求的 url 和参数了。在此情况下，就可以使用 redisson 的分布式锁来实现了

实现的思路步骤

使用分布式锁 redisson 来尝试获取一把锁
如果成功获取锁，再获取判断 redis 中的 key 值是否存在（key 值自定义）
如果 key 值不存在，则证明不是重复请求，再给 redis 中存入数据（使用 UUID 不重复）；反之，则证明是重复请求进行提交
最后，释放分布式锁

代码实现

Maven 依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson-spring-boot-starter</artifactId>
	<version>3.11.0</version>
</dependency>

配置文件配置 redis 信息

# redis 的配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0
spring.redis.timeout=2000
spring.redis.lettuce.pool.max-active=10
spring.redis.lettuce.pool.max-wait=2
spring.redis.lettuce.pool.min-idle=5
spring.redis.lettuce.pool.max-idle=10

RedissonClient 配置类

@Configuration
public class RedissonConfig {

	@Bean
	public RedissonClient redissonClient() {
		Config config = new Config();
		config.useSingleServer().setAddress("redis://127.0.0.1:6379");
		RedissonClient client = Redisson.create(config);
		return client;
	}
}

controller 层，伪代码如下

@Controller
public class TestController {

	@Autowired
    private StringRedisTemplate stringRedisTemplate;

	@Autowired
	private RedissonClient redissonClient;

	@PostMapping(path="/registerLock")
	@ResponseBody
	public ResultMap registerLock(UserDto userDto) {
		RLock rLock = redissonClient.getLock(userDto.getUserName());   
		// redis中的key值
       	String key = userDto.getUserName() + "-redissonLock";
       	boolean resultLock = rLock.tryLock(30, 10, TimeUnit.SECONDS);
		if (resultLock) {
			try {        	
        		// 如果不存在key
        		if (!stringRedisTemplate.hasKey(key)) {
            		// 给redis中存入数据
            		stringRedisTemplate.opsForValue().set(key,UUID.randomUUID().toString(),10L,TimeUnit.SECONDS);
            		// .....................你的业务
            		
            	}
            	// 如果存在，则提示不可重复提交
            	return new ResultMap().fail().message("请勿重复提交");
    		} catch (Exception e) {
    			return new ResultMap().fail().message("获取redisson分布式锁异常");
    		}
		} finally {
    		// 释放锁
        	rLock.unlock();
    	}
		return null;
	}
}