SpringBoot 接口防抖的一些实现方案
分布式部署下如何做接口防抖?
有两个方案:
使用共享缓存
流程图如下:
使用分布式锁
流程图如下:
常见的分布式组件有Redis、Zookeeper等,但结合实际业务来看,一般都会选择Redis,因为Redis一般都是Web系统必备的组件,不需要额外搭建。
具体实现
现在有一个保存用户的接口
@PostMapping("/add") @RequiresPermissions(value = "add") @Log(methodDesc = "添加用户") public ResponseEntity<String> add(@RequestBody AddReq addReq) { return userService.add(addReq); }
AddReq.java
package com.summo.demo.model.request; import java.util.List; import lombok.Data; @Datapublic class AddReq { /** * 用户名称 */ private String userName; /** * 用户手机号 */ private String userPhone; /** * 角色ID列表 */ private List<Long> roleIdList; }
目前数据库表中没有对userPhone字段做UK索引,这就会导致每调用一次add就会创建一个用户,即使userPhone相同。
根据上面的要求,我定了一个注解@RequestLock,使用方式很简单,把这个注解打在接口方法上即可。
- RequestLock.java
package com.summo.demo.model.request; import java.util.List; import lombok.Data; @Data public class AddReq { /** * 用户名称 */ private String userName; /** * 用户手机号 */ private String userPhone; /** * 角色ID列表 */ private List<Long> roleIdList; }
@RequestLock注解定义了几个基础的属性,redis锁前缀、redis锁时间、redis锁时间单位、key分隔符。其中前面三个参数比较好理解,都是一个锁的基本信息。
key分隔符是用来将多个参数合并在一起的,比如userName是张三,userPhone是123456,那么完整的key就是"张三&123456",最后再加上redis锁前缀,就组成了一个唯一key。
唯一key生成
这里有些同学可能就要说了,直接拿参数来生成key不就行了吗?额,不是不行,但我想问一个问题:如果这个接口是文章发布的接口,你也打算把内容当做key吗?要知道,Redis的效率跟key的大小息息相关。所以,我的建议是选取合适的字段作为key就行了,没必要全都加上。
要做到参数可选,那么用注解的方式最好了,注解如下
- RequestKeyParam.java
package com.example.requestlock.lock.annotation; import java.lang.annotation.*; /** * @description 加上这个注解可以将参数设置为key */ @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface RequestKeyParam { }
这个注解加到参数上就行,没有多余的属性。
接下来就是lockKey的生成了,代码如下
- RequestKeyGenerator.java
import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.util.ReflectionUtils; import org.springframework.util.StringUtils; public class RequestKeyGenerator { /** * 获取LockKey * * @param joinPoint 切入点 * @return */ public static String getLockKey(ProceedingJoinPoint joinPoint) { //获取连接点的方法签名对象 MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature(); //Method对象 Method method = methodSignature.getMethod(); //获取Method对象上的注解对象 RequestLock requestLock = method.getAnnotation(RequestLock.class); //获取方法参数 final Object[] args = joinPoint.getArgs(); //获取Method对象上所有的注解 final Parameter[] parameters = method.getParameters(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < parameters.length; i++) { final RequestKeyParam keyParam = parameters[i].getAnnotation(RequestKeyParam.class); //如果属性不是RequestKeyParam注解,则不处理 if (keyParam == null) { continue; } //如果属性是RequestKeyParam注解,则拼接 连接符 "& + RequestKeyParam" sb.append(requestLock.delimiter()).append(args[i]); } //如果方法上没有加RequestKeyParam注解 if (StringUtils.isEmpty(sb.toString())) { //获取方法上的多个注解(为什么是两层数组:因为第二层数组是只有一个元素的数组) final Annotation[][] parameterAnnotations = method.getParameterAnnotations(); //循环注解 for (int i = 0; i < parameterAnnotations.length; i++) { final Object object = args[i]; //获取注解类中所有的属性字段 final Field[] fields = object.getClass().getDeclaredFields(); for (Field field : fields) { //判断字段上是否有RequestKeyParam注解 final RequestKeyParam annotation = field.getAnnotation(RequestKeyParam.class); //如果没有,跳过 if (annotation == null) { continue; } //如果有,设置Accessible为true(为true时可以使用反射访问私有变量,否则不能访问私有变量) field.setAccessible(true); //如果属性是RequestKeyParam注解,则拼接 连接符" & + RequestKeyParam" sb.append(requestLock.delimiter()).append(ReflectionUtils.getField(field, object)); } } } //返回指定前缀的key return requestLock.prefix() + sb; } }
由于
@RequestKeyParam
可以放在方法的参数上,也可以放在对象的属性上,所以这里需要进行两次判断,一次是获取方法上的注解,一次是获取对象里面属性上的注解重复提交判断
Redis缓存方式
- RedisRequestLockAspect.java
- RequestKeyGenerator.java
import java.lang.reflect.Method; import com.summo.demo.exception.biz.BizException; import com.summo.demo.model.response.ResponseCodeEnum; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.core.annotation.Order; import org.springframework.data.redis.connection.RedisStringCommands; import org.springframework.data.redis.core.RedisCallback; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.types.Expiration; import org.springframework.util.StringUtils; /** * @description 缓存实现 */ @Aspect @Configuration @Order(2) public class RedisRequestLockAspect { private final StringRedisTemplate stringRedisTemplate; @Autowired public RedisRequestLockAspect(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)") public Object interceptor(ProceedingJoinPoint joinPoint) { MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature(); Method method = methodSignature.getMethod(); RequestLock requestLock = method.getAnnotation(RequestLock.class); if (StringUtils.isEmpty(requestLock.prefix())) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空"); } //获取自定义key final String lockKey = RequestKeyGenerator.getLockKey(joinPoint); // 使用RedisCallback接口执行set命令,设置锁键;设置额外选项:过期时间和SET_IF_ABSENT选项 final Boolean success = stringRedisTemplate.execute( (RedisCallback<Boolean>)connection -> connection.set(lockKey.getBytes(), new byte[0], Expiration.from(requestLock.expire(), requestLock.timeUnit()), RedisStringCommands.SetOption.SET_IF_ABSENT)); if (!success) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试"); } try { return joinPoint.proceed(); } catch (Throwable throwable) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常"); } } }
这里的核心代码是
stringRedisTemplate.execute
里面的内容,正如注释里面说的“使用RedisCallback
接口执行set命令,设置锁键;设置额外选项:过期时间和SET_IF_ABSENT选项”,有些同学可能不太清楚SET_IF_ABSENT
是个啥?这里我解释一下:
SET_IF_ABSENT
是RedisStringCommands.SetOption
枚举类中的一个选项,用于在执行 SET 命令时设置键值对的时候,如果键不存在则进行设置,如果键已经存在,则不进行设置。
Redisson分布式方式
Redisson分布式需要一个额外依赖,引入方式
<dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.10.6</version> </dependency>
由于我之前的代码有一个RedisConfig,引入Redisson之后也需要单独配置一下,不然会和RedisConfig冲突
- RedissonConfig.java
import org.redisson.Redisson; import org.redisson.api.RedissonClient; import org.redisson.config.Config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RedissonConfig { @Bean public RedissonClient redissonClient() { Config config = new Config(); // 这里假设你使用单节点的Redis服务器 config.useSingleServer() // 使用与Spring Data Redis相同的地址 .setAddress("redis://127.0.0.1:6379"); // 如果有密码 //.setPassword("xxxx"); // 其他配置参数 //.setDatabase(0) //.setConnectionPoolSize(10) //.setConnectionMinimumIdleSize(2); // 创建RedissonClient实例 return Redisson.create(config); } }
配好之后,核心代码如下
- RedissonRequestLockAspect.java
import java.lang.reflect.Method; import com.summo.demo.exception.biz.BizException; import com.summo.demo.model.response.ResponseCodeEnum; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.reflect.MethodSignature; import org.redisson.api.RLock; import org.redisson.api.RedissonClient; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.core.annotation.Order; import org.springframework.util.StringUtils; /** * @description 分布式锁实现 */ @Aspect @Configuration @Order(2) public class RedissonRequestLockAspect { private RedissonClient redissonClient; @Autowired public RedissonRequestLockAspect(RedissonClient redissonClient) { this.redissonClient = redissonClient; } @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)") public Object interceptor(ProceedingJoinPoint joinPoint) { MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature(); Method method = methodSignature.getMethod(); RequestLock requestLock = method.getAnnotation(RequestLock.class); if (StringUtils.isEmpty(requestLock.prefix())) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空"); } //获取自定义key final String lockKey = RequestKeyGenerator.getLockKey(joinPoint); // 使用Redisson分布式锁的方式判断是否重复提交 RLock lock = redissonClient.getLock(lockKey); boolean isLocked = false; try { //尝试抢占锁 isLocked = lock.tryLock(); //没有拿到锁说明已经有了请求了 if (!isLocked) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试"); } //拿到锁后设置过期时间 lock.lock(requestLock.expire(), requestLock.timeUnit()); try { return joinPoint.proceed(); } catch (Throwable throwable) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常"); } } catch (Exception e) { throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试"); } finally { //释放锁 if (isLocked && lock.isHeldByCurrentThread()) { lock.unlock(); } } } }
Redisson的核心思路就是抢锁,当一次请求抢到锁之后,对锁加一个过期时间,在这个时间段内重复的请求是无法获得这个锁,也不难理解。
测试一下。
第一次提交,"添加用户成功"
短时间内重复提交,"BIZ-0001:您的操作太快了,请稍后重试"
过几秒后再次提交,"添加用户成功"
从测试的结果上看,防抖是做到了,但是随着缓存消失、锁失效,还是可以发起同样的请求,所以要真正做到接口幂等性,还需要业务代码的判断、设置数据库表的UK索引等操作。
我在文章里面说到生成唯一key的时候没有加用户相关的信息,比如用户ID、IP属地等,真实生产环境建议加上这些,可以更好地减少误判。
- RedissonRequestLockAspect.java
- RequestKeyParam.java