SpringBoot实现接口限流的常用方案

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.48.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>33.4.8-jre</version>
        </dependency>
    </dependencies>

spring:
  data:
    redis:
      host: redis
      port: 6379

@SpringBootApplication
public class RateLimitApplication {

    public static void main(String[] args) {
        SpringApplication.run(RateLimitApplication.class, args);
    }
}

@Slf4j
@RestController
@RequestMapping(value = "redisson/rate-limit")
public class RedissonRateLimitController {

    @Autowired
    private RedissonClient redissonClient;

    @PostMapping("create-order")
    public Object createOrder(String info){
        RRateLimiter rateLimiter = getLimiter();
        boolean b = rateLimiter.tryAcquire();
        if(b) {
            log.info("允许访问");
            return "SUCCESS";
        }
        log.warn("限流了");
        throw new RuntimeException("请求太火爆");
    }

    /**
     * 获取限流器
     * @return
     */
    private RRateLimiter getLimiter() {
        RRateLimiter rateLimiter = redissonClient.getRateLimiter("create-order");
        rateLimiter.trySetRate(RateType.PER_CLIENT, 20, Duration.ofSeconds(5L));
        return rateLimiter;
    }

}

@Slf4j
@RestController
@RequestMapping(value = "guava/rate-limit")
public class GuavaRateLimitController {

    private static final RateLimiter rateLimiter = RateLimiter.create(5);

    @PostMapping("create-order")
    public Object createOrder(String info){
        boolean b = rateLimiter.tryAcquire();
        if(b) {
            log.info("允许访问");
            return "SUCCESS";
        }
        log.warn("限流了");
        throw new RuntimeException("请求太火爆");
    }


}

http {
    # 定义限流共享内存区（名称=one，大小=10MB，速率=10请求/秒）
    limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;

    # 其他全局配置...
    include       mime.types;
    default_type  application/octet-stream;
}

server {
    listen       80;
    server_name  example.com;

    location /api/ {
        # 应用限流规则（使用上面定义的 zone=one）
        limit_req zone=one burst=20 nodelay;  # burst=突发容量，nodelay=不等待直接拒绝
        
        # 被限流时返回 429 状态码，并跳转到自定义错误页
        limit_req_status_code 429;
        error_page 429 /custom_limit_msg;

        # 正常请求的反向代理（示例）
        proxy_pass http://backend_server;
    }

    # 自定义限流消息体（返回 JSON）
    location = /custom_limit_msg {
        internal;  # 仅内部访问，禁止外部直接请求
        add_header Content-Type application/json;
        return 429 '{"code": 429, "message": "请求过于频繁，请稍后再试"}';
    }
}

http {
    # 限流键为 X-User-ID 头的值（需确保头存在）
    limit_req_zone $http_x_user_id zone=user_limit:10m rate=5r/s;

    server {
        location /api/user/ {
            # 校验 X-User-ID 头是否存在，不存在则拒绝
            if ($http_x_user_id = "") {
                return 400 "Missing X-User-ID header";
            }
            
            # 应用限流（键为用户 ID）
            limit_req zone=user_limit burst=10 nodelay;
            limit_req_status_code 429;
            error_page 429 /custom_limit_msg;
            
            proxy_pass http://backend_server;
        }
    }
}