如何实现接口防刷

本文探讨了如何通过Interceptor和Redis实现接口访问防刷,通过拦截器统计访问次数,结合Redis防止接口被频繁访问。文章指出,现有实现需要优化,包括接口自由、时间逻辑漏洞和路径参数问题,并提出了自定义注解+反射的方法,以实现更灵活的接口防刷策略。此外,文章还讨论了真实IP获取和总结了接口防刷的思考过程。
摘要由CSDN通过智能技术生成

前言

  • 本文为描述通过Interceptor以及Redis实现接口访问防刷Demo
  • 这里会通过逐步找问题,逐步去完善的形式展示

原理

  • 通过ip地址+uri拼接用以作为访问者访问接口区分
  • 通过在Interceptor中拦截请求,从Redis中统计用户访问接口次数从而达到接口防刷目的
  • 如下图所示

 

其中,Interceptor处代码处理逻辑最为重要

 

/**
 * @author: Zero
 * @time: 2023/2/14
 * @description: 接口防刷拦截处理
 */
@Slf4j
public class AccessLimintInterceptor  implements HandlerInterceptor {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 多长时间内
     */
    @Value("${interfaceAccess.second}")
    private Long second = 10L;
​
    /**
     * 访问次数
     */
    @Value("${interfaceAccess.time}")
    private Long time = 3L;
​
    /**
     * 禁用时长--单位/秒
     */
    @Value("${interfaceAccess.lockTime}")
    private Long lockTime = 60L;
​
    /**
     * 锁住时的key前缀
     */
    public static final String LOCK_PREFIX = "LOCK";
​
    /**
     * 统计次数时的key前缀
     */
    public static final String COUNT_PREFIX = "COUNT";
​
​
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
​
        String uri = request.getRequestURI();
        String ip = request.getRemoteAddr(); // 这里忽略代理软件方式访问,默认直接访问,也就是获取得到的就是访问者真实ip地址
        String lockKey = LOCK_PREFIX + ip + uri;
        Object isLock = redisTemplate.opsForValue().get(lockKey);
        if(Objects.isNull(isLock)){
            // 还未被禁用
            String countKey = COUNT_PREFIX + ip + uri;
            Object count = redisTemplate.opsForValue().get(countKey);
            if(Objects.isNull(count)){
                // 首次访问
                log.info("首次访问");
                redisTemplate.opsForValue().set(countKey,1,second, TimeUnit.SECONDS);
            }else{
                // 此用户前一点时间就访问过该接口
                if((Integer)count < time){
                    // 放行,访问次数 + 1
                    redisTemplate.opsForValue().increment(countKey);
                }else{
                    log.info("{}禁用访问{}",ip, uri);
                    // 禁用
                    redisTemplate.opsForValue().set(lockKey, 1,lockTime, TimeUnit.SECONDS);
                    // 删除统计
                    redisTemplate.delete(countKey);
                    throw new CommonException(ResultCode.ACCESS_FREQUENT);
                }
            }
        }else{
            // 此用户访问此接口已被禁用
            throw new CommonException(ResultCode.ACCESS_FREQUENT);
        }
        return true;
    }
}
复制代码
    • 在多长时间内访问接口多少次,以及禁用的时长,则是通过与配置文件配合动态设置

 

    • 当处于禁用时直接抛异常则是通过在ControllerAdvice处统一处理(这里代码写的有点丑陋)

 

  • 下面是一些测试(可以把项目通过Git还原到“【初始化】”状态进行测试)
    • 正常访问时

 

 

    • 访问次数过于频繁时

### 回答1: 在 Spring 中,可以使用 AOP(面向切面编程)来实现接口防刷的功能。下面是一个示例实现: 1. 在项目的 pom.xml 文件中加入 AOP 的依赖: ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 2. 创建一个切面类,用于处理接口防刷逻辑,例如: ``` @Aspect @Component public class AntiBrushAspect { @Autowired private RedisTemplate redisTemplate; @Pointcut("@annotation(com.example.annotation.AntiBrush)") public void antiBrushPointcut() { } @Around("antiBrushPointcut()") public Object doAntiBrush(ProceedingJoinPoint joinPoint) throws Throwable { MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); AntiBrush antiBrush = method.getAnnotation(AntiBrush.class); int frequency = antiBrush.frequency(); long time = antiBrush.time(); String key = getKey(joinPoint, method); // 检查请求频率是否超过限制 if (checkFrequency(key, frequency, time)) { return Result.fail("请求过于频繁"); } try { return joinPoint.proceed(); } finally { // 更新请求频率 updateFrequency(key, frequency, time); } } private String getKey(ProceedingJoinPoint joinPoint, Method method) { // 获取请求的 IP 地址 String ip = RequestUtil.getIpAddr(); // 获取请求的方法名 String methodName = method.getName(); // 生成 Redis 的键 return String.format("anti_brush:%s:%s", ip, methodName); } private boolean checkFrequency(String key, int frequency, long time) { // 获取当前时间 long now = System.currentTimeMillis(); // 获取 Redis 中的记录 List<Long> records = (List<Long>) redisTemplate.opsForValue(). ### 回答2: Spring Boot提供了AOP(Aspect Oriented Programming,面向切面编程)的支持,可以通过切面实现接口防刷的功能。 首先,我们需要创建一个切面类,用于在接口被调用时进行处理。可以通过使用`@Aspect`来声明这个类是一个切面类,使用`@Component`将其注册为Spring Bean。 ```java @Aspect @Component public class RateLimitAspect { // 存储接口调用次数的缓存,这里使用ConcurrentHashMap private Map<String, AtomicInteger> counterMap = new ConcurrentHashMap<>(); // 定义切入点,这里设置为所有带有@RequestMapping注解的方法 @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)") public void requestMappingPointcut() {} // 定义环绕通知,用于在接口被调用前进行处理 @Around("requestMappingPointcut()") public Object handleRateLimit(ProceedingJoinPoint joinPoint) throws Throwable { // 获取请求的URL String url = getRequestUrl(joinPoint); // 检查接口调用次数是否超过阈值 if (isRateLimitExceeded(url)) { throw new RuntimeException("接口调用频率超过限制"); } // 接口调用次数加1 incrementRateLimit(url); // 执行接口方法 return joinPoint.proceed(); } // 获取请求的URL private String getRequestUrl(ProceedingJoinPoint joinPoint) { MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); RequestMapping annotation = method.getAnnotation(RequestMapping.class); return annotation.value()[0]; } // 检查接口调用次数是否超过阈值 private boolean isRateLimitExceeded(String url) { AtomicInteger counter = counterMap.get(url); return counter != null && counter.get() >= 5; // 假设阈值为5 } // 接口调用次数加1 private void incrementRateLimit(String url) { counterMap.computeIfAbsent(url, k -> new AtomicInteger()).incrementAndGet(); } } ``` 在切面类中,我们使用了一个Map来存储接口调用的次数,使用ConcurrentHashMap保证线程安全。在`handleRateLimit`方法中,我们首先通过`getRequestUrl`方法获取请求的URL,然后通过`isRateLimitExceeded`方法判断接口是否超过了阈值,如果超过则抛出异常。最后,我们通过`incrementRateLimit`方法将接口调用次数加1。 请注意,以上示例仅供参考,具体的实现方式可能因具体需求而有所不同。接口防刷实现可能需要考虑更多的因素,比如IP限制、令牌桶算法等。 ### 回答3: Spring Boot提供了AOP(面向切面编程)的支持,通过使用AOP可以很方便地实现接口防刷的功能。 首先,在Spring Boot项目中添加依赖,包括spring-boot-starter-aop和spring-boot-starter-web。 然后,创建一个切面类,用于实现接口防刷的逻辑。在该类上加上@Aspect注解,表示这是一个切面类。然后可以定义一个切点,用于指定需要进行拦截的接口方法。 示例代码如下: ```java import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; import java.util.HashMap; import java.util.Map; @Aspect @Component public class InterfaceLimiterAspect { private static final Map<String, Integer> frequencyMap = new HashMap<>(); /** * 定义切点,对需要进行拦截的接口方法进行限制 */ @Before("execution(* com.example.controller.*.*(..))") public void limitInterfaceFrequency(JoinPoint joinPoint) throws Exception { // 获取接口方法的名称 String methodName = joinPoint.getSignature().toLongString(); // 判断是否已经达到了阈值 if (frequencyMap.containsKey(methodName) && frequencyMap.get(methodName) >= 10) { throw new Exception("接口频率超过限制"); } else { // 将接口方法加入到频率统计中 frequencyMap.put(methodName, frequencyMap.getOrDefault(methodName, 0) + 1); } } } ``` 上述示例代码中,切面类InterfaceLimiterAspect用于实现接口防刷的逻辑。在@Before注解中,通过execution表达式指定了需要进行拦截的接口方法,这里是拦截了com.example.controller包下的所有方法。 在切面方法中,通过JoinPoint对象获取到当前正在执行的接口方法的名称,然后在frequencyMap中判断该接口方法的访问频率是否超过限制,如果超过限制,则抛出异常;如果没有超过限制,则将接口方法的访问次数加1。 最后,在Spring Boot的启动类中添加@EnableAspectJAutoProxy注解,开启AOP的自动代理功能,使得切面生效。 以上就是一个简单的Spring Boot接口防刷的切面实现。需要注意的是,该示例中只是简单地通过接口方法的访问次数进行限制,并没有考虑到并发访问的情况。在实际开发中,可能需要结合其他的技术或工具来实现更精确的接口访问频率限制。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值