经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » 编程经验 » 查看文章
《优化接口设计的思路》系列:第六篇—接口防抖(防重复提交)的一些方式
来源:cnblogs  作者:sum墨  时间:2023/12/11 10:24:36  对本文有异议

一、前言

大家好!我是sum墨,一个一线的底层码农,平时喜欢研究和思考一些技术相关的问题并整理成文,限于本人水平,如果文章和代码有表述不当之处,还请不吝赐教。

作为一名从业已达六年的老码农,我的工作主要是开发后端Java业务系统,包括各种管理后台和小程序等。在这些项目中,我设计过单/多租户体系系统,对接过许多开放平台,也搞过消息中心这类较为复杂的应用,但幸运的是,我至今还没有遇到过线上系统由于代码崩溃导致资损的情况。这其中的原因有三点:一是业务系统本身并不复杂;二是我一直遵循某大厂代码规约,在开发过程中尽可能按规约编写代码;三是经过多年的开发经验积累,我成为了一名熟练工,掌握了一些实用的技巧。

本文参考项目源码地址:summo-springboot-interface-demo

二、啥是防抖

所谓防抖,一是防用户手抖,二是防网络抖动。在Web系统中,表单提交是一个非常常见的功能,如果不加控制,容易因为用户的误操作或网络延迟导致同一请求被发送多次,进而生成重复的数据记录。要针对用户的误操作,前端通常会实现按钮的loading状态,阻止用户进行多次点击。而对于网络波动造成的请求重发问题,仅靠前端是不行的。为此,后端也应实施相应的防抖逻辑,确保在网络波动的情况下不会接收并处理同一请求多次。

一个理想的防抖组件或机制,我觉得应该具备以下特点:

  1. 逻辑正确,也就是不能误判;
  2. 响应迅速,不能太慢;
  3. 易于集成,逻辑与业务解耦;
  4. 良好的用户反馈机制,比如提示“您点击的太快了”

三、思路解析

前面讲了那么多,我们已经知道接口的防抖是很有必要的了,但是在开发之前,我们需要捋清楚几个问题。

1. 哪一类接口需要防抖?

接口防抖也不是每个接口都需要加,一般需要加防抖的接口有这几类:

  • 用户输入类接口:比如搜索框输入、表单输入等,用户输入往往会频繁触发接口请求,但是每次触发并不一定需要立即发送请求,可以等待用户完成输入一段时间后再发送请求。

  • 按钮点击类接口:比如提交表单、保存设置等,用户可能会频繁点击按钮,但是每次点击并不一定需要立即发送请求,可以等待用户停止点击一段时间后再发送请求。

  • 滚动加载类接口:比如下拉刷新、上拉加载更多等,用户可能在滚动过程中频繁触发接口请求,但是每次触发并不一定需要立即发送请求,可以等待用户停止滚动一段时间后再发送请求。

2. 如何确定接口是重复的?

防抖也即防重复提交,那么如何确定两次接口就是重复的呢?首先,我们需要给这两次接口的调用加一个时间间隔,大于这个时间间隔的一定不是重复提交;其次,两次请求提交的参数比对,不一定要全部参数,选择标识性强的参数即可;最后,如果想做的更好一点,还可以加一个请求地址的对比。

3. 分布式部署下如何做接口防抖?

有两个方案:

(1)使用共享缓存

流程图如下:

(2)使用分布式锁

流程图如下:

常见的分布式组件有Redis、Zookeeper等,但结合实际业务来看,一般都会选择Redis,因为Redis一般都是Web系统必备的组件,不需要额外搭建。

四、具体实现

现在有一个保存用户的接口

  1. @PostMapping("/add")
  2. @RequiresPermissions(value = "add")
  3. @Log(methodDesc = "添加用户")
  4. public ResponseEntity<String> add(@RequestBody AddReq addReq) {
  5. return userService.add(addReq);
  6. }

**AddReq.java **

  1. package com.summo.demo.model.request;
  2. import java.util.List;
  3. import lombok.Data;
  4. @Data
  5. public class AddReq {
  6. /**
  7. * 用户名称
  8. */
  9. private String userName;
  10. /**
  11. * 用户手机号
  12. */
  13. private String userPhone;
  14. /**
  15. * 角色ID列表
  16. */
  17. private List<Long> roleIdList;
  18. }

目前数据库表中没有对userPhone字段做UK索引,这就会导致每调用一次add就会创建一个用户,即使userPhone相同。

1. ??请求锁

根据上面的要求,我定了一个注解@RequestLock,使用方式很简单,把这个注解打在接口方法上即可。
RequestLock.java

  1. import java.lang.annotation.Documented;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Inherited;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  7. import java.util.concurrent.TimeUnit;
  8. /**
  9. * @description 请求防抖锁,用于防止前端重复提交导致的错误
  10. */
  11. @Target(ElementType.METHOD)
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Documented
  14. @Inherited
  15. public @interface RequestLock {
  16. /**
  17. * redis锁前缀
  18. *
  19. * @return 默认为空,但不可为空
  20. */
  21. String prefix() default "";
  22. /**
  23. * redis锁过期时间
  24. *
  25. * @return 默认2秒
  26. */
  27. int expire() default 2;
  28. /**
  29. * redis锁过期时间单位
  30. *
  31. * @return 默认单位为秒
  32. */
  33. TimeUnit timeUnit() default TimeUnit.SECONDS;
  34. /**
  35. * redis key分隔符
  36. *
  37. * @return 分隔符
  38. */
  39. String delimiter() default "&";
  40. }

@RequestLock注解定义了几个基础的属性,redis锁前缀、redis锁时间、redis锁时间单位、key分隔符。其中前面三个参数比较好理解,都是一个锁的基本信息。key分隔符是用来将多个参数合并在一起的,比如userName是张三,userPhone是123456,那么完整的key就是"张三&123456",最后再加上redis锁前缀,就组成了一个唯一key。

2. 唯一key生成

这里有些同学可能就要说了,直接拿参数来生成key不就行了吗?
额,不是不行,但我想问一个问题:如果这个接口是文章发布的接口,你也打算把内容当做key吗?要知道,Redis的效率跟key的大小息息相关。所以,我的建议是选取合适的字段作为key就行了,没必要全都加上

要做到参数可选,那么用注解的方式最好了,注解如下
RequestKeyParam.java

  1. package com.example.requestlock.lock.annotation;
  2. import java.lang.annotation.*;
  3. /**
  4. * @description 加上这个注解可以将参数设置为key
  5. */
  6. @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Documented
  9. @Inherited
  10. public @interface RequestKeyParam {
  11. }

这个注解加到参数上就行,没有多余的属性。

接下来就是lockKey的生成了,代码如下
RequestKeyGenerator.java

  1. import java.lang.annotation.Annotation;
  2. import java.lang.reflect.Field;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Parameter;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.reflect.MethodSignature;
  7. import org.springframework.util.ReflectionUtils;
  8. import org.springframework.util.StringUtils;
  9. public class RequestKeyGenerator {
  10. /**
  11. * 获取LockKey
  12. *
  13. * @param joinPoint 切入点
  14. * @return
  15. */
  16. public static String getLockKey(ProceedingJoinPoint joinPoint) {
  17. //获取连接点的方法签名对象
  18. MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  19. //Method对象
  20. Method method = methodSignature.getMethod();
  21. //获取Method对象上的注解对象
  22. RequestLock requestLock = method.getAnnotation(RequestLock.class);
  23. //获取方法参数
  24. final Object[] args = joinPoint.getArgs();
  25. //获取Method对象上所有的注解
  26. final Parameter[] parameters = method.getParameters();
  27. StringBuilder sb = new StringBuilder();
  28. for (int i = 0; i < parameters.length; i++) {
  29. final RequestKeyParam keyParam = parameters[i].getAnnotation(RequestKeyParam.class);
  30. //如果属性不是RequestKeyParam注解,则不处理
  31. if (keyParam == null) {
  32. continue;
  33. }
  34. //如果属性是RequestKeyParam注解,则拼接 连接符 "& + RequestKeyParam"
  35. sb.append(requestLock.delimiter()).append(args[i]);
  36. }
  37. //如果方法上没有加RequestKeyParam注解
  38. if (StringUtils.isEmpty(sb.toString())) {
  39. //获取方法上的多个注解(为什么是两层数组:因为第二层数组是只有一个元素的数组)
  40. final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  41. //循环注解
  42. for (int i = 0; i < parameterAnnotations.length; i++) {
  43. final Object object = args[i];
  44. //获取注解类中所有的属性字段
  45. final Field[] fields = object.getClass().getDeclaredFields();
  46. for (Field field : fields) {
  47. //判断字段上是否有RequestKeyParam注解
  48. final RequestKeyParam annotation = field.getAnnotation(RequestKeyParam.class);
  49. //如果没有,跳过
  50. if (annotation == null) {
  51. continue;
  52. }
  53. //如果有,设置Accessible为true(为true时可以使用反射访问私有变量,否则不能访问私有变量)
  54. field.setAccessible(true);
  55. //如果属性是RequestKeyParam注解,则拼接 连接符" & + RequestKeyParam"
  56. sb.append(requestLock.delimiter()).append(ReflectionUtils.getField(field, object));
  57. }
  58. }
  59. }
  60. //返回指定前缀的key
  61. return requestLock.prefix() + sb;
  62. }
  63. }
  64. > 由于``@RequestKeyParam``可以放在方法的参数上,也可以放在对象的属性上,所以这里需要进行两次判断,一次是获取方法上的注解,一次是获取对象里面属性上的注解。

3. 重复提交判断

(1)Redis缓存方式

RedisRequestLockAspect.java

  1. import java.lang.reflect.Method;
  2. import com.summo.demo.exception.biz.BizException;
  3. import com.summo.demo.model.response.ResponseCodeEnum;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.reflect.MethodSignature;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.core.annotation.Order;
  11. import org.springframework.data.redis.connection.RedisStringCommands;
  12. import org.springframework.data.redis.core.RedisCallback;
  13. import org.springframework.data.redis.core.StringRedisTemplate;
  14. import org.springframework.data.redis.core.types.Expiration;
  15. import org.springframework.util.StringUtils;
  16. /**
  17. * @description 缓存实现
  18. */
  19. @Aspect
  20. @Configuration
  21. @Order(2)
  22. public class RedisRequestLockAspect {
  23. private final StringRedisTemplate stringRedisTemplate;
  24. @Autowired
  25. public RedisRequestLockAspect(StringRedisTemplate stringRedisTemplate) {
  26. this.stringRedisTemplate = stringRedisTemplate;
  27. }
  28. @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)")
  29. public Object interceptor(ProceedingJoinPoint joinPoint) {
  30. MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  31. Method method = methodSignature.getMethod();
  32. RequestLock requestLock = method.getAnnotation(RequestLock.class);
  33. if (StringUtils.isEmpty(requestLock.prefix())) {
  34. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空");
  35. }
  36. //获取自定义key
  37. final String lockKey = RequestKeyGenerator.getLockKey(joinPoint);
  38. // 使用RedisCallback接口执行set命令,设置锁键;设置额外选项:过期时间和SET_IF_ABSENT选项
  39. final Boolean success = stringRedisTemplate.execute(
  40. (RedisCallback<Boolean>)connection -> connection.set(lockKey.getBytes(), new byte[0],
  41. Expiration.from(requestLock.expire(), requestLock.timeUnit()),
  42. RedisStringCommands.SetOption.SET_IF_ABSENT));
  43. if (!success) {
  44. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");
  45. }
  46. try {
  47. return joinPoint.proceed();
  48. } catch (Throwable throwable) {
  49. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常");
  50. }
  51. }
  52. }

这里的核心代码是stringRedisTemplate.execute里面的内容,正如注释里面说的“使用RedisCallback接口执行set命令,设置锁键;设置额外选项:过期时间和SET_IF_ABSENT选项”,有些同学可能不太清楚SET_IF_ABSENT是个啥,这里我解释一下:SET_IF_ABSENT 是 RedisStringCommands.SetOption 枚举类中的一个选项,用于在执行 SET 命令时设置键值对的时候,如果键不存在则进行设置,如果键已经存在,则不进行设置。

(2)Redisson分布式方式

Redisson分布式需要一个额外依赖,引入方式

  1. <dependency>
  2. <groupId>org.redisson</groupId>
  3. <artifactId>redisson-spring-boot-starter</artifactId>
  4. <version>3.10.6</version>
  5. </dependency>

由于我之前的代码有一个RedisConfig,引入Redisson之后也需要单独配置一下,不然会和RedisConfig冲突
RedissonConfig.java

  1. import org.redisson.Redisson;
  2. import org.redisson.api.RedissonClient;
  3. import org.redisson.config.Config;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. public class RedissonConfig {
  8. @Bean
  9. public RedissonClient redissonClient() {
  10. Config config = new Config();
  11. // 这里假设你使用单节点的Redis服务器
  12. config.useSingleServer()
  13. // 使用与Spring Data Redis相同的地址
  14. .setAddress("redis://127.0.0.1:6379");
  15. // 如果有密码
  16. //.setPassword("xxxx");
  17. // 其他配置参数
  18. //.setDatabase(0)
  19. //.setConnectionPoolSize(10)
  20. //.setConnectionMinimumIdleSize(2);
  21. // 创建RedissonClient实例
  22. return Redisson.create(config);
  23. }
  24. }

配好之后,核心代码如下
RedissonRequestLockAspect.java

  1. mport java.lang.reflect.Method;
  2. import com.summo.demo.exception.biz.BizException;
  3. import com.summo.demo.model.response.ResponseCodeEnum;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.reflect.MethodSignature;
  8. import org.redisson.api.RLock;
  9. import org.redisson.api.RedissonClient;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.core.annotation.Order;
  13. import org.springframework.util.StringUtils;
  14. /**
  15. * @description 分布式锁实现
  16. */
  17. @Aspect
  18. @Configuration
  19. @Order(2)
  20. public class RedissonRequestLockAspect {
  21. private RedissonClient redissonClient;
  22. @Autowired
  23. public RedissonRequestLockAspect(RedissonClient redissonClient) {
  24. this.redissonClient = redissonClient;
  25. }
  26. @Around("execution(public * * (..)) && @annotation(com.summo.demo.config.requestlock.RequestLock)")
  27. public Object interceptor(ProceedingJoinPoint joinPoint) {
  28. MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  29. Method method = methodSignature.getMethod();
  30. RequestLock requestLock = method.getAnnotation(RequestLock.class);
  31. if (StringUtils.isEmpty(requestLock.prefix())) {
  32. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "重复提交前缀不能为空");
  33. }
  34. //获取自定义key
  35. final String lockKey = RequestKeyGenerator.getLockKey(joinPoint);
  36. // 使用Redisson分布式锁的方式判断是否重复提交
  37. RLock lock = redissonClient.getLock(lockKey);
  38. boolean isLocked = false;
  39. try {
  40. //尝试抢占锁
  41. isLocked = lock.tryLock();
  42. //没有拿到锁说明已经有了请求了
  43. if (!isLocked) {
  44. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");
  45. }
  46. //拿到锁后设置过期时间
  47. lock.lock(requestLock.expire(), requestLock.timeUnit());
  48. try {
  49. return joinPoint.proceed();
  50. } catch (Throwable throwable) {
  51. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常");
  52. }
  53. } catch (Exception e) {
  54. throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");
  55. } finally {
  56. //释放锁
  57. if (isLocked && lock.isHeldByCurrentThread()) {
  58. lock.unlock();
  59. }
  60. }
  61. }
  62. }

Redisson的核心思路就是抢锁,当一次请求抢到锁之后,对锁加一个过期时间,在这个时间段内重复的请求是无法获得这个锁,也不难理解。

4. 测试一下

  • 第一次提交,"添加用户成功"

  • 短时间内重复提交,"BIZ-0001:您的操作太快了,请稍后重试"

  • 过几秒后再次提交,"添加用户成功"

从测试的结果上看,防抖是做到了,但是随着缓存消失、锁失效,还是可以发起同样的请求,所以要真正做到接口幂等性,还需要业务代码的判断、设置数据库表的UK索引等操作。
我在文章里面说到生成唯一key的时候没有加用户相关的信息,比如用户ID、IP属地等,真实生产环境建议加上这些,可以更好地减少误判。

原文链接:https://www.cnblogs.com/wlovet/p/17875887.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号