分布式限流操作是为了保证服务避免受到过载，提高系统的性能稳定性以及提高系统可用性的有效手段之一，特别是在一些高并发请求环境下，分布式限流更是保证系统高效稳定的关键操作。下面我们就来总结一下在分布式场景下有哪些常用的限流手段。

基于Redis的令牌桶算法

令牌桶算法是在限流操作中的一种常见的限流算法，通过定时向令牌桶中加入指定数量的令牌来限制流量控制。

当每次请求到达之后，需要先从令牌桶中取出令牌，如果令牌桶中存在令牌那么就放行请求，否则就是拒绝请求操作，这种方式可以防止流量激增的情况，并且这种操作允许一定程度的突发流量，限流较灵活，比较适合在分布式场景下实现。

如下所示是基于Redis的令牌桶算法实现。

@Service
public class RateLimiterService {

    private static final String REDIS_TOKEN_BUCKET_KEY = "tokenBucket";
    private static final int MAX_TOKENS = 100;
    private static final int REFILL_RATE = 10; // 每秒添加 10 个令牌
    private final RedisTemplate<String, String> redisTemplate;

    public RateLimiterService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public boolean tryAcquire() {
        Long tokens = redisTemplate.opsForValue().get(REDIS_TOKEN_BUCKET_KEY);
        if (tokens == null || tokens <= 0) {
            return false;
        } else {
            redisTemplate.opsForValue().increment(REDIS_TOKEN_BUCKET_KEY, -1);
            return true;
        }
    }

    @Scheduled(fixedRate = 1000)
    public void refillTokens() {
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            Long tokens = Long.valueOf(redisTemplate.opsForValue().get(REDIS_TOKEN_BUCKET_KEY));
            if (tokens < MAX_TOKENS) {
                redisTemplate.opsForValue().increment(REDIS_TOKEN_BUCKET_KEY, REFILL_RATE);
            }
            return null;
        });
    }
}

在上面的实现中，首先需要在Redis中维护一个令牌桶。并且需要定期为令牌桶添加令牌。当请求到来的时候，就尝试从桶中取出令牌。如果成功取出令牌则允许请求，否则拒绝，当然这里的拒绝，我们也是可以进行一定程度的自定义扩展的，有兴趣的读者可以自己研究下。

基于Redis的漏桶算法

漏桶算法是以一个固定的速率处理请求，可以防止流量突然升高对后端请求产生影响。在每次请求进来之后，都会将请求先放入桶中，然后桶中的请求会以一个固定的速度从桶中流出。并且当桶装满的时候，有新的请求进入的时候则会被拒绝，这种方式适合处理一些比较平稳的请求流量。

如下所示，给出基于Redis的漏桶算法实现。

@Service
public class LeakyBucketService {

    private static final String REDIS_LEAKY_BUCKET_KEY = "leakyBucket";
    private static final int BUCKET_CAPACITY = 100;
    private static final int LEAK_RATE = 10; // 每秒漏出 10 个请求
    private final RedisTemplate<String, String> redisTemplate;

    public LeakyBucketService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public boolean tryAcquire() {
        Long water = redisTemplate.opsForValue().get(REDIS_LEAKY_BUCKET_KEY);
        if (water == null) {
            water = 0L;
        }
        if (water < BUCKET_CAPACITY) {
            redisTemplate.opsForValue().increment(REDIS_LEAKY_BUCKET_KEY, 1);
            return true;
        } else {
            return false;
        }
    }

    @Scheduled(fixedRate = 1000)
    public void leakBucket() {
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            redisTemplate.opsForValue().increment(REDIS_LEAKY_BUCKET_KEY, -LEAK_RATE);
            return null;
        });
    }
}

我们在Redis中模拟存储了漏桶，当每次请求到来时，检查漏桶是否已满，如果满了那么就拒绝请求进入，如果没有则进入漏洞，并且漏桶会每隔固定时间，减少漏桶中的请求数量，来模拟漏桶排水过程。

使用Nginx进行限流

对于在实际开发过程中，我们还可以通过Nginx进行限流，并且Nginx在设计之初就已经考虑到了限流操作，所以我们可以通过基于IP的方式来进行限流，通过Nginx限流不需要再代码逻辑中进行限流操作的处理，所以比较适合前端的流控。

如下所示，我们可以通过NGINX的配置来进行IP限流操作。

http {
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=1r/s;

    server {
        location /api/ {
            limit_req zone=mylimit burst=5 nodelay;
            proxy_pass http://localhost:8080;
        }
    }
}

该配置表示每个IP每秒最多可以发起1个请求，最多允许突发5个请求。

使用Guava RateLimiter

Guava 库是Google提供的库，在这个库中提供了一个简单的限流工具类RateLimiter，这个工具类是基于令牌桶算法实现限流。因为其简单的使用方式，所以比较适合对于单节点的限流操作，如下所示。

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.stereotype.Service;

@Service
public class GuavaRateLimiterService {

    private final RateLimiter rateLimiter = RateLimiter.create(10.0); // 每秒 10 个请求

    public boolean tryAcquire() {
        return rateLimiter.tryAcquire();
    }
}

使用Sentinel限流

Sentinel是阿里巴巴开源的一款流量防护工具，它支持丰富的限流规则和监控能力，适合微服务架构中的复杂限流需求。

在SpringBoot应用中我们可以引入Sentinel依赖并根据配置来进行指定规则API限流，如下所示。

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.stereotype.Service;

@Service
public class SentinelRateLimiterService {

    @SentinelResource(value = "resourceName", blockHandler = "handleBlocked")
    public String someMethod() {
        return "success";
    }

    public String handleBlocked(BlockException ex) {
        return "blocked by Sentinel";
    }
}

可以在sentinel-dashboard中进行动态修改限流规则。

自定义拦截器限流

在一些需要特别处理的场景中，我们还可以通过自定的拦截器进行限流，不过这种方式适合一些简单的操作，可以结合Redis、Zookeeper等方式来进行限流。

如下所示，我们可以先定义一个注解，然后通过AOP拦截器来实现请求限流操作。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int limit() default 5;
}

定义拦截器

@Aspect
@Component
public class RateLimitAspect {

    private final Map<String, Integer> requestCounts = new HashMap<>();

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        String key = joinPoint.getSignature().toString();
        requestCounts.putIfAbsent(key, 0);
        if (requestCounts.get(key) < rateLimit.limit()) {
            requestCounts.put(key, requestCounts.get(key) + 1);
            return joinPoint.proceed();
        } else {
            throw new RuntimeException("Too many requests");
        }
    }
}

总结

Spring Boot中实现分布式限流可以根据具体业务场景选择不同的方案。如果是分布式系统，推荐使用Redis进行分布式限流，结合令牌桶或漏桶算法，也可以通过Nginx进行前置限流。在复杂的微服务架构中，使用Sentinel是更合适的选择。而对于单体服务，使用Guava或者自定义拦截器限流也是不错的选择。