在现代微服务架构中，限流（Rate Limiting）是保障系统稳定性的重要手段之一。在实际使用场景中通过限流机制，我们可以防止接口被高频次的请求击垮，从而保护后端服务不被异常流量攻击。在Spring Boot中提供了很多种实现限流的方案，我们可以根据业务需求选择适合的方式。下面本文中我们将要介绍几种常见的限流策略，包括基于@RateLimiter注解的方案、Redis计数器限流、令牌桶算法等来实现接口限流。

为什么需要限流？

限流的主要目的是防止接口过载。当请求数量超出接口的承受能力时，如果没有限流，接口可能会发生超时，导致服务器宕机。因此，通过限流，我们可以保证系统的可用性、防止恶意用户通过高频率访问拖垮系统，同时在有限的资源下确保服务的稳定性。

实现限流的常见策略

基于Spring Cloud Gateway的限流（适用于网关层）

Spring Cloud Gateway是Spring官方推荐的微服务网关，其内部提供了内置的限流功能。例如通过基于Redis的滑动窗口算法来实现限流。可以通过配置文件来进行调整，如下所示。

spring:
  cloud:
    gateway:
      routes:
        - id: api_route
          uri: http://example.com
          predicates:
            - Path=/api/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10    # 每秒允许的请求数
                redis-rate-limiter.burstCapacity: 20     # 突发流量容量
                redis-rate-limiter.requestedTokens: 1    # 每次请求的token数量

以上配置代表每秒钟允许10个请求，突发流量可达到20个请求。

基于Spring注解实现限流

Spring Boot中可以使用@RateLimiter注解来实现限流。下面我们演示如何通过resilience4j库来实现注解限流。

引入resilience4j依赖

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.0</version>
</dependency>

配置限流策略

resilience4j:
  ratelimiter:
    configs:
      default:
        limit-for-period: 5               # 单位时间内的最大请求数
        limit-refresh-period: 1s          # 刷新间隔时间
        timeout-duration: 0               # 超时时间
    instances:
      myRateLimiter:
        base-config: default

使用@RateLimiter注解

@RestController
@RequestMapping("/api")
public class RateLimitedController {

    @GetMapping("/limited")
    @RateLimiter(name = "myRateLimiter", fallbackMethod = "rateLimitFallback")
    public String limitedApi() {
        return "Request successful!";
    }

    // 限流后的回退方法
    public String rateLimitFallback(Throwable t) {
        return "Too many requests - please try again later.";
    }
}

以上代码将接口/api/limited的请求数限制为每秒5次，超过限制则会调用rateLimitFallback方法。

基于Redis的限流

Redis非常适合在分布式环境下的限流操作，主要有滑动窗口算法和固定窗口计数器两种实现方法。下面我们介绍一个简单的基于计数器的限流方案，如下所示。

引入Redis依赖

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

实现限流逻辑

@RestController
@RequestMapping("/api")
public class RedisRateLimitedController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final int LIMIT = 5;            // 每分钟限制请求数
    private static final String KEY = "rate:limit";

    @GetMapping("/redis-limited")
    public String limitedApi() {
        Long count = redisTemplate.opsForValue().increment(KEY);
        if (count == 1) {
            // 设置key的过期时间为1分钟
            redisTemplate.expire(KEY, 1, TimeUnit.MINUTES);
        }
        if (count > LIMIT) {
            return "Too many requests - please try again later.";
        }
        return "Request successful!";
    }
}

每次请求会对Redis中的KEY计数器进行自增。当计数超过LIMIT（例如5次）时，返回限流提示。通过expire方法，设置KEY在1分钟后过期，以实现限流的时间窗口。

令牌桶算法限流

令牌桶算法是常用的限流算法之一，该算法通过在请求之前判断“令牌桶”内是否有令牌来限制请求频率。可以更好地应对突发流量问题，如下所示给出一个简单的实现过程。

首先先来创建一个令牌桶类。

public class TokenBucket {

    private final int maxTokens;
    private int tokens;
    private final ScheduledExecutorService scheduler;

    public TokenBucket(int maxTokens, int refillRate) {
        this.maxTokens = maxTokens;
        this.tokens = maxTokens;
        this.scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(this::refill, 0, 1000 / refillRate, TimeUnit.MILLISECONDS);
    }

    private synchronized void refill() {
        if (tokens < maxTokens) {
            tokens++;
        }
    }

    public synchronized boolean tryConsume() {
        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false;
    }
}

下面我们就来通过这个令牌桶来实现限流操作。

@RestController
@RequestMapping("/api")
public class TokenBucketController {

    private final TokenBucket tokenBucket = new TokenBucket(5, 1);

    @GetMapping("/token-limited")
    public String limitedApi() {
        if (tokenBucket.tryConsume()) {
            return "Request successful!";
        }
        return "Too many requests - please try again later.";
    }
}

在上面的实现中，TokenBucket类通过一个定时任务，每秒为桶添加一个令牌，通过tryConsume方法检查令牌数量并决定是否允许请求，从而实现请求流量限流操作。

总结

• 基于Spring Cloud Gateway的限流：适合在网关层进行限流，适合分布式环境。
• 基于注解的限流：使用@RateLimiter注解简单直观，适合中小规模项目。
• 基于Redis的限流：适合分布式环境，可支持更多复杂的限流需求。
• 基于令牌桶算法的限流：可更好地应对突发流量，适合需要平稳流量控制的场景。

这些限流策略可以单独使用，也可以结合使用，具体选择需要根据系统的架构和业务需求来决定。希望本文能帮助大家在Spring Boot项目中实现灵活、有效的限流策略。