接上一篇内容接口也会累着！Spring Boot + Redis 实现接口限流和防刷，这一篇接着学习Spring Boot + Redis实现接口防刷！

接口防刷是常见的一种防御方式。接口防刷指的是对于同一个IP地址在短时间内发送大量的请求，从而导致系统资源被耗尽，从而导致系统崩溃或响应变慢的行为进行限制。

为了解决这个问题，我们可以使用Spring Boot和Redis的组合来实现接口防刷。本文将介绍如何使用Spring Boot和Redis来实现接口防刷的功能。

实现思路

接口防刷的主要思路是限制同一IP在一定时间内的请求次数。具体实现方式是在Redis中使用一个计数器来记录每个IP地址的请求次数，同时使用Redis的过期时间特性来限制计数器的生命周期。当某个IP地址的请求次数超过限制时，返回错误提示信息。

下面是实现接口防刷的步骤：

• 在Redis中创建一个计数器，以IP地址作为键名。
• 每次收到请求时，从Redis中获取对应IP地址的计数器，如果计数器不存在，则创建一个新的计数器。
• 如果计数器的值超过了设定的阈值，则返回错误提示信息。
• 每次请求成功后，将计数器的值加1，并设置计数器的过期时间。
• 定期清理Redis中已过期的计数器，以释放内存。

代码实现

pom.xml文件配置

首先，在Spring Boot的pom.xml文件中添加以下依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

这个依赖将Spring Boot与Redis集成在一起，让我们可以方便地使用Redis。

Redis

在Spring Boot中配置Redis，需要在application.properties文件中添加以下配置：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.database=0
spring.redis.password=
spring.redis.timeout=5000
spring.redis.pool.max-active=8
spring.redis.pool.max-idle=8
spring.redis.pool.max-wait=-1

这些配置项包括了Redis的连接信息，如主机名、端口号、密码等，还包括了连接池的相关配置，如最大活动连接数、最大空闲连接数等。

编写拦截器

拦截器是Spring Boot中用来拦截请求的组件。在拦截器中，我们可以检查请求是否合法，如果不合法则返回错误提示信息。

首先，我们需要创建一个拦截器类，继承HandlerInterceptorAdapter类，并实现其中的preHandle方法。preHandle方法在请求到达控制器之前执行，我们可以在这个方法中对请求进行处理。

下面是一个简单的拦截器示例：

public class RateLimiterInterceptor extends HandlerInterceptorAdapter {
    
    private RedisTemplate<String, Object> redisTemplate;
    private int limit; // 单位时间内最多允许的请求次数
    private int expire; // 计数器过期时间，单位秒

    public RateLimiterInterceptor(RedisTemplate<String, Object> redisTemplate, int limit, int expire) {
        this.redisTemplate = redisTemplate;
        this.limit = limit;
        this.expire = expire;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String ip = getIpAddress(request); // 获取请求的IP地址
        String key = "rate_limiter:" + ip; // 构造Redis键名
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        if (redisTemplate.hasKey(key)) { // 如果计数器存在，则检查请求次数是否超过限制
            int count = (int) ops.get(key);
            if (count >= limit) {
                response.sendError(HttpStatus.TOO_MANY_REQUESTS.value(), "请求过于频繁，请稍后再试");
                return false;
            } else {
                ops.increment(key); // 请求次数加1
            }
        } else { // 如果计数器不存在，则创建一个新的计数器，并设置过期时间
            ops.set(key, 1, expire, TimeUnit.SECONDS);
        }
        return true;
    }

    private String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

在上面的代码中，我们使用了RedisTemplate来访问Redis，并在拦截器中实现了限制请求次数的逻辑。拦截器的作用是在请求到达控制器之前对请求进行拦截，检查请求的IP地址对应的计数器是否已经存在，如果存在，则检查请求次数是否超过限制，如果超过限制，则返回错误提示信息；如果计数器不存在，则创建一个新的计数器，并设置过期时间。

在上面的代码中，我们通过构造Redis键名来实现不同IP地址对应的计数器的区分。在计数器存在的情况下，我们使用Redis的increment方法将计数器的值加1；在计数器不存在的情况下，我们使用Redis的set方法创建一个新的计数器，并设置过期时间。

注册拦截器

为了让Spring Boot识别我们编写的拦截器，我们需要将拦截器注册到Spring Boot的拦截器链中。这可以通过在WebMvcConfigurerAdapter中重写addInterceptors方法来实现。

下面是一个简单的WebMvcConfigurerAdapter示例：

@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        RateLimiterInterceptor interceptor = new RateLimiterInterceptor(redisTemplate, 10, 60); // 限制每个IP地址每分钟最多请求10次
        registry.addInterceptor(interceptor).addPathPatterns("/**");
    }
}

在上面的代码中，我们创建了一个RateLimiterInterceptor对象，并将它注册到拦截器链中。在注册拦截器时，我们还指定了拦截的路径，这里使用了通配符“/**”，表示拦截所有路径的请求。

测试接口

为了测试我们编写的接口防刷功能，我们可以编写一个简单的REST接口，并使用curl工具发送请求。下面是一个示例：

@RestController
public class TestController {

    @GetMapping("/test")
    public String test() {
        return "success";
    }
}

在上面的代码中，我们定义了一个简单的REST接口“/test”，返回字符串“success”。

我们可以使用curl工具发送多个请求来测试接口防刷功能。下面是一个示例：

curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test
curl http://localhost:8080/test

在上面的代码中，我们发送了10个请求，如果每个IP地址每分钟最多请求10次，则前9个请求应该返回“success”，最后一个请求应该返回“请求过于频繁，请稍后再试”。

总结

通过本文的学习，我们了解了接口防刷的概念和原理，掌握了如何使用Spring Boot和Redis实现接口防刷的功能。在实际开发中，我们可以根据实际需求调整阈值和时间窗口，以达到最佳的接口防刷效果。