嘿，各位后端开发的伙伴们！在日常开发工作里，大家是不是经常碰到这样的问题：用户在前端一顿疯狂操作，猛点按钮或者飞速提交表单，结果后端接口就收到了一连串重复请求。这不但浪费服务器资源，还可能引发数据不一致等诸多麻烦事。今天，咱们就来深入探讨在 Spring Boot3 中，如何巧妙实现接口防抖操作，一举解决这个令人头疼的问题。
问题引入
设想你正在开发一个电商系统的订单提交接口。用户在付款页面，由于网络卡顿，没看到提交按钮的响应，一着急就多点了好几次。此时，要是接口没有防抖机制，订单系统很可能会收到多条完全一样的订单提交请求，进而导致重复下单、库存混乱，给用户和商家都带来极大困扰。再比如在社交平台的点赞接口中，用户不小心手抖多点了几下，要是没有接口防抖，用户的点赞数就会瞬间不正常地飙升，这显然不是我们期望的结果。那么，怎样才能避免这种情况呢？这就是我们今天要全力攻克的接口防抖难题。
在当今高并发的互联网应用场景下，接口的稳定性和性能极为关键。接口防抖作为一种常见的优化方式，主要功能是防止在短时间内多次触发同一操作。用户端可能由于网络延迟、误操作等原因，在短时间内多次发送相同请求。如果后端接口不加以管控，这些请求一股脑涌入服务器，服务器就得重复处理相同业务逻辑，这无疑会加重服务器负担，严重时甚至可能致使系统崩溃。而且，多次处理重复请求还可能引发数据一致性问题，比如重复向数据库插入相同数据。所以，实现接口防抖对于提升系统性能、保障数据准确性和稳定性意义重大。
解决方案
基于注解和 AOP 实现防抖
定义防抖注解
首先，我们自定义一个防抖注解，比如@RequestLock。在这个注解里，我们可以设置一些参数，像timeUnit用来指定锁时间的单位（默认可以设为秒），delimiter用于参数分隔，方便生成唯一的锁key。示例代码如下：
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLock {
long value() default 1;
TimeUnit timeUnit() default TimeUnit.SECONDS;
String delimiter() default "&";
}生成唯一key
为了准确判断两次请求是否重复，我们需要生成一个唯一的key。这个key可以由请求参数和注解中的配置共同组成。例如，对于一个添加用户的接口，请求参数中有用户名userName和用户手机号userPhone，我们可以选择这两个参数来生成key。假设userName是 “张三”，userPhone是 “123456”，按照注解中设置的分隔符 “&”，生成的key就是 “张三 & 123456”，再加上注解中设置的锁前缀，就构成了一个唯一标识此次请求的key。具体生成key的代码逻辑如下（这里以反射获取方法参数为例）：
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 {
public static String getLockKey(ProceedingJoinPoint joinPoint, RequestLock requestLock) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
Parameter[] parameters = method.getParameters();
Object[] args = joinPoint.getArgs();
StringBuilder keyBuilder = new StringBuilder(requestLock.prefix());
for (int i = 0; i < parameters.length i parameter parameter='parameters[i];' object arg='args[i];' if parameter.isannotationpresentrequestkeyparam.class if arg if keybuilder.length> requestLock.prefix().length()) {
keyBuilder.append(requestLock.delimiter());
}
keyBuilder.append(arg.toString());
}
}
}
return keyBuilder.toString();
}
}这里RequestKeyParam是一个自定义注解，用于标记哪些参数参与key的生成。
实现防抖逻辑（基于 Redis）
我们利用 Redis 的setnx命令来实现防抖逻辑。setnx（即SET if Not eXists）命令可以判断指定的key是否存在，如果不存在就设置这个key并返回成功，否则直接返回失败。我们在获取锁成功后，给锁设置一个过期时间，防止死锁。当方法执行完成后，手动删除锁。示例代码如下（基于 Spring Data Redis）：
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.util.concurrent.TimeUnit;
@Aspect
@Component
public class RequestLockAspect {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Around("@annotation(requestLock)")
public Object around(ProceedingJoinPoint joinPoint, RequestLock requestLock) throws Throwable {
String lockKey = RequestKeyGenerator.getLockKey(joinPoint, requestLock);
boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "locked", requestLock.value(), requestLock.timeUnit());
if (!success) {
throw new RuntimeException("请求过于频繁，请稍后再试");
}
try {
return joinPoint.proceed();
} finally {
stringRedisTemplate.delete(lockKey);
}
}
}应用防抖注解
最后，在需要防抖的接口方法上加上@RequestLock注解就大功告成啦。比如一个保存用户信息的接口：
@PostMapping("/saveUser")
@RequestLock(value = 2, timeUnit = TimeUnit.SECONDS)
public ResponseEntity saveUser(@RequestBody User user) {
// 保存用户信息的业务逻辑
return ResponseEntity.ok("用户信息保存成功");
} 这个接口设置了 2 秒的防抖时间，在这 2 秒内，如果收到相同参数的重复请求，就会提示 “请求过于频繁，请稍后再试”。
使用 Guava 的 RateLimiter 实现限流防抖
引入依赖
首先在pom.xml文件中引入 Guava 的依赖：
com.google.guava
guava
32.1.2-jre
配置 RateLimiter
在 Spring Boot 的配置类中，我们可以创建一个RateLimiter的实例，并设置每秒允许通过的请求数。例如，我们设置每秒只允许通过 5 个请求：
import com.google.common.util.concurrent.RateLimiter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RateLimiterConfig {
@Bean
public RateLimiter rateLimiter() {
return RateLimiter.create(5);
}
}在接口中使用 RateLimiter
在需要防抖的接口方法中，获取RateLimiter实例并调用tryAcquire方法尝试获取令牌。如果获取成功，说明请求在限流范围内，可以继续处理；如果获取失败，说明请求过于频繁，需要返回错误提示。示例代码如下：
import com.google.common.util.concurrent.RateLimiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@Autowired
private RateLimiter rateLimiter;
@PostMapping("/addUser")
public ResponseEntity addUser(@RequestBody User user) {
if (!rateLimiter.tryAcquire()) {
return ResponseEntity.status(429).body("请求过于频繁，请稍后再试");
}
// 添加用户的业务逻辑
return ResponseEntity.ok("用户添加成功");
}
} 这种方式通过限制请求的速率来实现防抖，适用于对请求频率有严格控制的场景。
总结
今天我们深入探讨了在 Spring Boot3 中实现接口防抖的两种常见且有效的方案。无论是基于注解和 AOP 利用 Redis 实现的防抖，还是借助 Guava 的 RateLimiter 实现的限流防抖，都能很好地应对高并发场景下的重复请求问题，提升我们系统的性能和稳定性。大家在实际项目中不妨试试这些方法，根据业务场景的特点选择最适合的方案。如果你在实现过程中有任何疑问或者遇到了有趣的问题，欢迎在评论区留言分享，咱们一起交流进步。同时，也别忘了点赞、收藏这篇文章，说不定以后在项目中就能派上用场哦！