Java分布式限流案例怎么开发

wen java案例 2026-06-28 30

Java分布式限流案例开发实战：从原理到高并发落地

目录导读

为什么分布式系统必须考虑限流？
分布式限流的核心算法对比（令牌桶 vs 漏桶 vs 滑动窗口）
基于Redis + Lua实现分布式限流（含完整代码案例）
使用Sentinel实现集群限流（Spring Cloud Alibaba集成）
常见问题与问答（FAQ）
性能优化与最佳实践

为什么分布式系统必须考虑限流？

在微服务架构中,单个服务节点可以通过本地限流（如Guava RateLimiter）控制流量，但当流量分散到多个实例（如Kubernetes多Pod）时，本地限流会失效，你为每个实例设置了100 QPS，部署了5个实例，但外部恶意请求可能同时打满所有实例，导致总QPS达到500，最终压垮下游数据库或第三方服务。

Java分布式限流案例怎么开发

分布式限流的核心目标：在集群层面统一控制总请求速率，确保系统在任何时刻都不超过预设阈值。

分布式限流核心算法对比

算法	原理	优缺点	适用场景
令牌桶	固定速率生成令牌，桶满则丢弃；请求需获取令牌才能执行	✅ 允许突发流量（桶可缓存令牌）；❌ 实现稍复杂	API网关、秒杀系统
漏桶	请求以固定速率流出，不管流入速率多快	✅ 强制平滑流量；❌ 无法应对突发请求	数据库写入限流
滑动窗口	将时间划分为小窗口，统计每个窗口请求数	✅ 精度高（避免临界问题）；❌ 内存占用随窗口数增加	实时监控、短时精准限流

推荐：令牌桶 + Redis，因为它在允许突发流量的同时，通过Redis原子性操作保证分布式一致性。

基于Redis + Lua实现分布式限流（核心案例）

1 设计思路

存储结构：使用Redis的KEY存储当前令牌数，KEY:last_refill_time存储上次补充时间。
原子性：通过Lua脚本一次性完成“补充令牌+扣减令牌+返回结果”，避免并发竞争。
参数：key（用户/接口ID）、capacity（桶容量）、rate（每秒生成令牌数）、cost（每次请求消耗令牌数，默认为1）。

2 完整Lua脚本

-- 参数：KEYS[1]=令牌桶key, ARGV[1]=容量, ARGV[2]=速率, ARGV[3]=当前时间戳(秒), ARGV[4]=消耗令牌数
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local cost = tonumber(ARGV[4])
-- 获取当前令牌数
local tokens = redis.call("get", key)
local last_refill = redis.call("get", key .. ":last_refill")
if tokens == false then
    -- 首次初始化：全部令牌
    tokens = capacity
    last_refill = now
else
    tokens = tonumber(tokens)
    last_refill = tonumber(last_refill)
    -- 计算需要补充的令牌数
    local elapsed = now - last_refill
    local add_tokens = elapsed * rate
    if add_tokens > 0 then
        tokens = math.min(tokens + add_tokens, capacity)
        last_refill = now
    end
end
if tokens >= cost then
    tokens = tokens - cost
    — 更新到Redis
    redis.call("set", key, tokens)
    redis.call("set", key .. ":last_refill", last_refill)
    return 1  — 允许请求
else
    return 0  — 拒绝请求
end

3 Java调用代码（使用Spring Data Redis）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Service;
import java.util.Collections;
@Service
public class DistributedRateLimiter {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    // 加载Lua脚本（脚本内容按上述）
    private static final String LUA_SCRIPT = "local key = KEYS[1] ..."; // 完整脚本粘贴
    private static final RedisScript<Long> RATE_LIMIT_SCRIPT = RedisScript.of(LUA_SCRIPT, Long.class);
    public boolean tryAcquire(String key, int capacity, int rate, int cost) {
        long now = System.currentTimeMillis() / 1000;
        Long result = redisTemplate.execute(
                RATE_LIMIT_SCRIPT,
                Collections.singletonList(key),
                String.valueOf(capacity),
                String.valueOf(rate),
                String.valueOf(now),
                String.valueOf(cost)
        );
        return result != null && result == 1L;
    }
}

4 测试验证

public class RateLimitTest {
    public static void main(String[] args) throws InterruptedException {
        RateLimiter limiter = new RateLimiter(); // 假设已注入
        String key = "api:order:create";
        for (int i = 0; i < 20; i++) {
            boolean allowed = limiter.tryAcquire(key, 10, 2, 1); // 容量10，每秒2个
            System.out.println("请求" + i + ": " + (allowed ? "通过" : "被限流"));
            Thread.sleep(100);
        }
    }
}

输出预期：前10个请求快速通过（消耗桶中初始10个令牌），之后每0.5秒通过1个（因为rate=2/s），超出部分被限流。

使用Sentinel实现集群限流（生产级方案）

如果不想自己维护Lua脚本，推荐阿里开源的Sentinel，它原生支持集群限流。

1 集成步骤（Spring Cloud Alibaba）

引入依赖（pom.xml）：

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<dependency>
 <groupId>com.alibaba.csp</groupId>
 <artifactId>sentinel-cluster-client-default</artifactId>
</dependency>

配置限流规则（application.yml）：

sentinel:
transport:
 dashboard: localhost:8080  # 控制台地址
datasource:
 ds1:
   nacos:
     server-addr: localhost:8848
     dataId: sentinel-rules
     groupId: DEFAULT_GROUP
     rule-type: flow

定义资源（Java代码）：

@RestController
public class OrderController {
 @SentinelResource(value = "createOrder", blockHandler = "handleBlock")
 public String createOrder() {
     return "下单成功";
 }
 public String handleBlock(BlockException ex) {
     return "被限流，请稍后重试";
 }
}