目录

  • 1. 前言
  • 2. 防止表单重复提交
  • 2.1. 单机
  • 2.1.1. 实现的思路步骤
  • 2.1.2. 代码实现
  • 2.2. 分布式
  • 2.2.1. 实现的思路步骤
  • 2.2.2. 代码实现


1. 前言

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

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

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

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

2. 防止表单重复提交

2.1. 单机

2.1.1. 实现的思路步骤

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

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

2.1.2. 代码实现

  • 创建自定义注解
@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 {

		//.....
	}
}

2.2. 分布式

java防止多次提交 spring防止重复提交_spring


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

2.2.1. 实现的思路步骤

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

2.2.2. 代码实现

  • 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;
	}
}