限流与配额治理体系——令牌桶、漏桶在不同场景的优缺点与实现位置选择

用户请求 → 网关层限流（全局防护）→ 应用层限流（业务防护）→ 资源层限流（基础防护）→ 数据层限流（最终防护）

// Go语言令牌桶实现示例
type TokenBucket struct {
    capacity  int64     // 桶容量
    tokens    int64     // 当前令牌数
    rate      int64     // 令牌生成速率(个/秒)
    lastTime  time.Time // 最后刷新时间
    mutex     sync.Mutex
}

func (tb *TokenBucket) Allow() bool {
    tb.mutex.Lock()
    defer tb.mutex.Unlock()
    
    now := time.Now()
    elapsed := now.Sub(tb.lastTime).Seconds()
    tb.lastTime = now
    
    // 计算新生成的令牌数
    newTokens := int64(elapsed * float64(tb.rate))
    tb.tokens = min(tb.capacity, tb.tokens+newTokens)
    
    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

// Java漏桶算法简化实现
public class LeakyBucket {
    private final long capacity;    // 桶容量
    private final long rate;        // 流出速率(请求/秒)
    private long water;             // 当前水量
    private long lastLeakTime;      // 上次漏水时间
    
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 计算自上次以来流出的水量
        long leaked = (now - lastLeakTime) * rate / 1000;
        water = Math.max(0, water - leaked);
        lastLeakTime = now;
        
        if (water < capacity) {
            water++;
            return true;
        }
        return false;
    }
}

# API网关限流配置
rate_limit:
  - name: "user_api_global"
    key: "ip_address"           # 基于IP限流
    algorithm: "token_bucket"
    limit: 1000                 # 容量
    interval: "1s"             # 时间窗口
    burst: 100                  # 突发容量
  - name: "user_api_business"
    key: "user_id"              # 基于用户ID限流  
    algorithm: "sliding_window"
    limit: 100                  # 每用户每分钟限制
    interval: "60s"

@Service
public class OrderService {
    // 针对不同接口的差异化限流
    private final RateLimiter createOrderLimiter = 
        RateLimiter.create(100); // 创建订单: 100QPS
    
    private final RateLimiter queryOrderLimiter = 
        RateLimiter.create(500); // 查询订单: 500QPS
        
    public Order createOrder(CreateRequest request) {
        if (!createOrderLimiter.tryAcquire()) {
            throw new BusinessException("请求过于频繁，请稍后重试");
        }
        // 业务逻辑处理
    }
}

-- Redis Lua脚本实现原子性分布式限流
local key = KEYS[1]        -- 限流键
local limit = tonumber(ARGV[1])  -- 限制数
local window = tonumber(ARGV[2]) -- 时间窗口
local current = redis.call('GET', key)
 
if current and tonumber(current) > limit then
    return 0  -- 超过限制
end
 
current = redis.call('INCR', key)
if tonumber(current) == 1 then
    redis.call('EXPIRE', key, window)
end
 
return 1  -- 允许通过

@Component
public class AdaptiveRateLimiter {
    public double calculateDynamicLimit() {
        double baseLimit = 1000; // 基础限流值
        double systemLoad = getSystemLoadFactor(); // 0.0-1.0
        double successRate = getRecentSuccessRate(); // 最近成功率
        
        // 根据负载和成功率动态调整
        return baseLimit * (1 - systemLoad) * successRate;
    }
}

{
  "quota_usage": {
    "user_id": "12345",
    "api_name": "image_processing",
    "daily_limit": 1000,
    "used_today": 756,
    "remaining": 244,
    "reset_time": "2025-01-08T00:00:00Z",
    "alert_threshold": 0.8  // 80%使用率时告警
  }
}