▷ 优雅的接口防刷处理方式，看这一篇就够了

文章目录

1、API接口防刷1.1、概念1.2、原理1.3、目的1.4、实现方案介绍

2、方案一2.1、自定义注解2.2、拦截器2.3、Redis配置类2.4、注册拦截器2.5、测试2.6、Lua脚本实现方案

3、方案二3.1、自定义注解3.2、切面类3.3、测试

4、限流算法介绍（了解）4.1、令牌桶算法4.2、漏桶算法

5、总结

1、API接口防刷

1.1、概念

顾名思义，就是要实现某个接口在某段时间内只能让某人访问指定次数，超出次数，就不让访问了

1.2、原理

在请求的时候，服务器通过 Redis 记录下你请求的次数，如果次数超过限制就不给访问在 Redis 保存的 Redis 是有时效性的，过期就会删除

1.3、目的

主要防止短时间接口被大量调用（攻击），出现系统崩溃和系统爬虫问题，提升服务的可用性

1.4、实现方案介绍

拦截器+自定义注解+RedisAOP+自定义注解+Redis

我这里准备了一份基础代码：https://gitee.com/colinWu_java/spring-boot-base.git 接下来我会在此主干代码基础上进行开发

2、方案一

好，接下来我们直接实战编码，运用到项目中的话，非常实用，使用起来也非常方便，下面是我们需要写的几个核心类

自定义注解拦截器（核心）Redis配置类（设置序列化用）

2.1、自定义注解

package org.wujiangbo.annotation;

import java.lang.annotation.*;

/**

* 用于防刷限流的注解

* 默认是5秒内只能调用一次

*/

@Target({ ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface RateLimit {

/** 限流的key */

String key() default "limit:";

/** 周期,单位是秒 */

int cycle() default 5;

/** 请求次数 */

int count() default 1;

/** 默认提示信息 */

String msg() default "请勿重复点击";

}

2.2、拦截器

package org.wujiangbo.interceptor;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import org.springframework.web.method.HandlerMethod;

import org.springframework.web.servlet.HandlerInterceptor;

import org.wujiangbo.annotation.RateLimit;

import org.wujiangbo.exception.MyException;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.util.concurrent.TimeUnit;

/**

* 防刷限流的拦截器

* @author wujiangbo

* @date 2022-08-23 18:39

*/

@Component

public class RateLimitInterceptor implements HandlerInterceptor {

@Resource

private RedisTemplate redisTemplate;

@Override

public boolean preHandle(

HttpServletRequest request,

HttpServletResponse response,

Object handler) throws Exception {

// 如果请求的是方法，则需要做校验

if (handler instanceof HandlerMethod) {

HandlerMethod handlerMethod = (HandlerMethod) handler;

// 获取目标方法上是否有指定注解

RateLimit rateLimit = handlerMethod.getMethodAnnotation(RateLimit.class);

if (rateLimit == null) {

//说明目标方法上没有 RateLimit 注解

return true;

}

//代码执行到此，说明目标方法上有 RateLimit 注解，所以需要校验这个请求是不是在刷接口

// 获取请求IP地址

String ip = getIpAddr(request);

// 请求url路径

String uri = request.getRequestURI();

//存到redis中的key

String key = "RateLimit:" + ip + ":" + uri;

// 缓存中存在key，在限定访问周期内已经调用过当前接口

if (redisTemplate.hasKey(key)) {

// 访问次数自增1

redisTemplate.opsForValue().increment(key, 1);

// 超出访问次数限制

if (redisTemplate.opsForValue().get(key) > rateLimit.count()) {

throw new MyException(rateLimit.msg());

}

// 未超出访问次数限制，不进行任何操作，返回true

} else {

// 第一次设置数据,过期时间为注解确定的访问周期

redisTemplate.opsForValue().set(key, 1, rateLimit.cycle(), TimeUnit.SECONDS);

}

return true;

}

//如果请求的不是方法，直接放行

return true;

}

//获取请求的归属IP地址

private String getIpAddr(HttpServletRequest request) {

String ipAddress = null;

try {

ipAddress = request.getHeader("x-forwarded-for");

if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getHeader("Proxy-Client-IP");

}

if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getHeader("WL-Proxy-Client-IP");

}

if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getRemoteAddr();

}

// 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割

if (ipAddress != null && ipAddress.length() > 15) {

// = 15

if (ipAddress.indexOf(",") > 0) {

ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));

}

}

} catch (Exception e) {

ipAddress = "";

}

return ipAddress;

}

}

2.3、Redis配置类

package org.wujiangbo.config.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

/**

* Redis配置类

*/

@Configuration

public class RedisConfig {

@Bean

public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {

// 设置序列化

Jackson2JsonRedisSerializer