1. Bucket4j

类型: Token Bucket
持久化: 内存/分布式（如 Redis）
适用场景: 简单到复杂的限流场景
优势: 灵活的 API，易于与 Redis 集成

Java 实现:

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.Bucket4j;
import io.github.bucket4j.Refill;

public class Bucket4jExample {
    public static void main(String[] args) {
        // 定义限流规则：每秒 10 个请求
        Bandwidth limit = Bandwidth.classic(10, Refill.intervally(10, Duration.ofSeconds(1)));
        Bucket bucket = Bucket4j.builder().addLimit(limit).build();

        // 模拟请求
        for (int i = 0; i < 15; i++) {
            if (bucket.tryConsume(1)) {
                System.out.println("Request " + i + " allowed");
            } else {
                System.out.println("Request " + i + " blocked");
            }
        }
    }
}

2. Resilience4j

类型: Token Bucket + Others
持久化: 仅内存
适用场景: 容错和速率限制
优势: 结合了断路器、重试和速率限制

Java 实现:

import io.github.resilience4j.ratelimiter.RateLimiter;
import io.github.resilience4j.ratelimiter.RateLimiterConfig;

import java.time.Duration;

public class Resilience4jExample {
    public static void main(String[] args) {
        // 定义限流规则：每秒 5 个请求
        RateLimiterConfig config = RateLimiterConfig.custom()
                .limitForPeriod(5)
                .limitRefreshPeriod(Duration.ofSeconds(1))
                .build();
        RateLimiter rateLimiter = RateLimiter.of("myLimiter", config);

        // 模拟请求
        for (int i = 0; i < 10; i++) {
            if (rateLimiter.acquirePermission()) {
                System.out.println("Request " + i + " allowed");
            } else {
                System.out.println("Request " + i + " blocked");
            }
        }
    }
}

3. Guava RateLimiter

类型: Token Bucket
持久化: 仅内存
适用场景: 轻量级基本用例
优势: 使用简单，适合本地限流

Java 实现:

import com.google.common.util.concurrent.RateLimiter;

public class GuavaRateLimiterExample {
    public static void main(String[] args) {
        // 定义限流规则：每秒 2 个请求
        RateLimiter rateLimiter = RateLimiter.create(2);

        // 模拟请求
        for (int i = 0; i < 5; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + i + " allowed");
            } else {
                System.out.println("Request " + i + " blocked");
            }
        }
    }
}

4. Spring Cloud Gateway RateLimiter

类型: 基于 Redis 的可配置类型
持久化: Redis
适用场景: API 网关场景
优势: 响应式友好，易于与 Spring Cloud 集成

Java 实现:

# application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: myRoute
          uri: http://example.org
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

5. Envoy / Istio + Java

类型: 外部服务
持久化: 通过服务网格
适用场景: API 级别的速率限制
优势: 语言无关，外部化限制

实现:
使用 Envoy 或 Istio 配置限流规则，Java 应用无需额外代码。

6. Apache Shiro

类型: 可定制
持久化: 内存或自定义
适用场景: 认证和速率限制
优势: 安全与限流结合

Java 实现:

import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.SecurityUtils;

public class ShiroExample {
    public static void main(String[] args) {
        Subject currentUser = SecurityUtils.getSubject();
        if (currentUser.isPermitted("rateLimit:access")) {
            System.out.println("Request allowed");
        } else {
            System.out.println("Request blocked");
        }
    }
}

7. RateLimiter4j

类型: Token Bucket
持久化: Redis 或本地
适用场景: 简单的外部服务速率限制
优势: API 级别的控制，轻量级

Java 实现:

import com.github.marcosbento.ratelimiter4j.RateLimiter;

public class RateLimiter4jExample {
    public static void main(String[] args) {
        // 定义限流规则：每秒 3 个请求
        RateLimiter rateLimiter = new RateLimiter(3, 1);

        // 模拟请求
        for (int i = 0; i < 5; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + i + " allowed");
            } else {
                System.out.println("Request " + i + " blocked");
            }
        }
    }
}

8. Redis + Lua Scripts

类型: 自定义
持久化: Redis
适用场景: 高规模分布式系统
优势: 高度可定制，适合后端 API

Java 实现:
使用 Redis 和 Lua 脚本实现限流逻辑，Java 通过 Jedis 或 Lettuce 调用 Redis。

import redis.clients.jedis.Jedis;

public class RedisLuaExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String luaScript = "local current = redis.call('incr', KEYS[1])\n" +
                "if current == 1 then\n" +
                "    redis.call('expire', KEYS[1], ARGV[1])\n" +
                "end\n" +
                "if current > tonumber(ARGV[2]) then\n" +
                "    return 0\n" +
                "else\n" +
                "    return 1\n" +
                "end";
        String key = "rateLimitKey";
        String limit = "10";
        String expire = "60";
        Object result = jedis.eval(luaScript, 1, key, expire, limit);
        System.out.println("Request allowed: " + result.equals(1L));
    }
}

以上为 八种 常见的 Java 限流的实现方案，你掌握了么？