基于Redis实现接口调用频率限制是一种常见的解决方案，一般情况下通过这种方式来防止接口被频繁请求、防止恶意攻击或流量控制。我们可以通过使用Redis的自增操作来记录每个请求者的调用次数，设置过期时间来表示一个时间窗口如1秒或1分钟，并对每个请求者的调用频率进行限制。下面我们就来看看如何在SpringBoot中通过Redis来实现一个接口限流操作。

添加依赖

首先，需要在项目中添加Redis相关的依赖配置，如下所示。

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

在application.yml配置文件中添加Redis连接配置信息，如下。

spring:
  redis:
    host: localhost
    port: 6379

编写限流逻辑

一般情况下，我们可以通过Redis的INCR和EXPIRE操作来实现限流操作，主要原理就是每个请求者可以通过 IP、用户 ID 等标识，然后通过INCR计数请求次数，通过EXPIRE设置过期时间，用于定义时间窗口。超过设定的请求次数后，拒绝请求并返回提示。

创建Redis工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedisRateLimiter {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 尝试增加请求计数并判断是否超过限制
     * @param key Redis的键值, 可以是IP或用户标识
     * @param limit 限制的最大请求数
     * @param timeout 超时时间窗口, 单位秒
     * @return 是否超限, 超过返回true
     */
    public boolean isOverLimit(String key, int limit, long timeout) {
        Long count = redisTemplate.opsForValue().increment(key, 1);
        
        // 如果第一次调用，设置过期时间
        if (count == 1) {
            redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
        }
        
        // 判断是否超过限制
        return count > limit;
    }
}

创建限流注解

为了在程序代码中方便使用，我们可以自定义一个注解来实现限流操作，如下所示。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})  // 作用在方法上
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int limit() default 5;  // 默认每秒5次
    int timeout() default 1;  // 默认1秒
}

创建注解处理器

通过AOP操作来拦截带有@RateLimit注解的方法，然后对其进行限流操作处理。

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.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Aspect
@Component
public class RateLimitAspect {

    @Autowired
    private RedisRateLimiter redisRateLimiter;

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        // 获取请求IP或用户标识
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ip = request.getRemoteAddr();

        // 生成Redis的Key，可以是IP或其他用户标识
        String key = "rate_limit:" + ip;

        // 判断是否超过限制
        if (redisRateLimiter.isOverLimit(key, rateLimit.limit(), rateLimit.timeout())) {
            // 如果超过限制，可以抛出异常或返回特定的响应
            return "Too many requests, please try again later.";
        }

        // 执行原方法
        return joinPoint.proceed();
    }
}

这里需要注意，通过上面这种方式有可能会存在获取不到真实的用户IP的情况，尤其是在应用部署在反向代理服务器（如 Nginx、Apache）或负载均衡器之后的时候。HttpServletRequest.getRemoteAddr()获取到的可能是代理服务器的 IP 地址，而不是客户端的真实IP。这种情况下，如果直接使用getRemoteAddr()，限流机制就可能基于代理服务器的IP，而不是每个用户的IP，导致限流不准确。

为了获取用户的真实IP地址，通常需要检查HTTP请求头中是否包含真实IP地址。常见的HTTP头字段包括如下几种方式。

• X-Forwarded-For：通常用于记录客户端的原始 IP 地址，多个代理服务器之间可能会添加多个 IP 地址，客户端的真实 IP 是第一个。
• X-Real-IP：部分代理服务器也可能使用这个头字段传递客户端的真实 IP。

改进获取真实用户IP的代码

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.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Aspect
@Component
public class RateLimitAspect {

    @Autowired
    private RedisRateLimiter redisRateLimiter;

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        // 获取请求对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        
        // 获取客户端的真实IP地址
        String ip = getClientIP(request);

        // 生成Redis的Key，可以是IP或其他用户标识
        String key = "rate_limit:" + ip;

        // 判断是否超过限制
        if (redisRateLimiter.isOverLimit(key, rateLimit.limit(), rateLimit.timeout())) {
            // 如果超过限制，可以抛出异常或返回特定的响应
            return "Too many requests, please try again later.";
        }

        // 执行原方法
        return joinPoint.proceed();
    }

    /**
     * 获取客户端真实IP
     * @param request HttpServletRequest 对象
     * @return 真实的客户端IP
     */
    private String getClientIP(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        // X-Forwarded-For可能返回多个IP地址，第一个为真实IP
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0].trim();
        }
        
        return ip;
    }
}

如果使用了Nginx作为反向代理，确保在Nginx中配置了传递真实IP的相关配置，如下所示。

server {
    listen 80;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
    }
}

总结

通过Redis实现接口的调用频率限制具有高效性和分布式支持的特点，适用于高并发的场景。这个方案利用了Redis的自增和过期时间功能来记录请求次数，并限制请求频率。此外，使用自定义注解和AOP让限流逻辑更为简洁易用。这种方式可以很好地实现基于Redis的限流，避免了接口被滥用。