SpringBoot四十一：防止重复提交

前言

场景：同一个用户在n秒内对同一URL的提交视为重复提交。

在传统的web项目中，为了防止重复提交，通常做法是：后端生成唯一的提交令牌（token），存储在服务端，页面在发起请求时，携带次令牌，后端验证请求后删除令牌，保证请求的唯一性。

但是，上述的做法是需要前后端都需要进行改动，如果在项目初期，是可以实现的，但是，在项目的后期，很多功能都实现好了，不可能大范围的去改动。

AOP防止请求重复提交

pom.xml

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<exclusion>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</exclusion>
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

配置文件

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
#spring.redis.password=yourpwd
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8  
# 连接池最大阻塞等待时间
spring.redis.jedis.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8  
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0  
# 连接超时时间（毫秒）
spring.redis.timeout=5000ms

自定义注解

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 NoRepeatSubmit {

    /**
     * 设置请求锁定时间
     *
     * @return
     */
    int lockTime() default 10;

}

AOP

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.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.TimeUnit;

@Aspect
@Component
public class NoRepeatSubmitAop {

    @Autowired
    private StringRedisTemplate redisTemplate;

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

    @Around("pointCut(noRepeatSubmit)")
    public Object around(ProceedingJoinPoint pjp, NoRepeatSubmit noRepeatSubmit) throws Throwable {
        int lockSeconds = noRepeatSubmit.lockTime();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Assert.notNull(request, "请求不能为空!");
      String sessionId = RequestContextHolder.getRequestAttributes().getSessionId();
        String path = request.getServletPath();
        String key = sessionId + "-" + path;

        // 如果缓存中有这个url视为重复提交
        if (!redisTemplate.hasKey(key)) {
            Object o = pjp.proceed();
            redisTemplate.opsForValue().set(key, String.valueOf(0), lockSeconds, TimeUnit.SECONDS);
            return o;
        } else {
            return "重复请求，请稍后再试！";
        }
    }
}

测试接口

import cn.com.javakf.aop.NoRepeatSubmit;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SubmitController {

   @GetMapping("submit")
   @NoRepeatSubmit(lockTime = 5)
    public String submit() {
        return "请求成功！";
   }

}

测试
http://localhost:8080/submit

token方式：https://www.bilibili.com/read/cv5639326/
Redis分布式锁：https://blog.csdn.net/a992795427/article/details/92834286