Java案例如何实现限流功能？

wen java案例 2026-06-10 13

Java案例：如何实现限流功能？从原理到实战全面解析

目录导读

什么是限流？为什么需要限流？
常见的限流算法及其Java实现
- 计数器算法（固定窗口）
- 滑动窗口算法
- 漏桶算法
- 令牌桶算法
Java限流实战：基于Spring Boot的案例
- 使用RateLimiter实现API限流
- 基于AOP + 注解实现分布式限流
限流常见问题与优化策略
问答环节：限流高频面试题解析

什么是限流？为什么需要限流？

Q：什么是限流？
A：限流（Rate Limiting）是一种控制访问速率的技术，它限制单位时间内对某个资源（如API、数据库、服务）的请求次数,防止系统因突发流量而过载。

Java案例如何实现限流功能？

Q：为什么需要限流？
A：在Java高并发场景下,无限制的流量可能导致：

服务响应变慢甚至宕机
数据库连接池耗尽
内存溢出（OutOfMemoryError）
下游服务雪崩

典型应用场景：秒杀系统、消息队列消费、API网关、搜索引擎爬虫控制等。

常见的限流算法及其Java实现

计数器算法（固定窗口）

原理：将时间划分为固定窗口（如1秒），每个窗口内维护一个计数器,超过阈值则拒绝请求。

优缺点：

✅ 实现简单
❌ 存在临界突变问题（窗口边界处可能瞬间涌入2倍流量）

Java代码示例：

public class FixedWindowRateLimiter {
    private final int maxRequests;
    private final long windowSize;
    private int currentCount;
    private long windowStart;
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (now - windowStart > windowSize) {
            windowStart = now;
            currentCount = 0;
        }
        if (currentCount < maxRequests) {
            currentCount++;
            return true;
        }
        return false;
    }
}

滑动窗口算法

原理：将固定窗口细分为多个小格子，记录每个格子内的请求数,滑动窗口实时统计。

优缺点：

✅ 避免临界突变
❌ 需要存储多个时间片的数据，内存占用略高

漏桶算法（Leaky Bucket）

原理：请求先进入“桶”中，桶以固定速率流出；桶满则丢弃请求。
特点：强制平滑流量，适合处理突发流量不敏感的场景（如消息推送）。

令牌桶算法（Token Bucket）——最常用

原理：以固定速率往桶中放入令牌，请求需消耗令牌才能通过；桶满时令牌不再增加。

优势：

允许一定程度的突发流量（桶内可积累最多burst数量的令牌）
实现简单，性能高

Java实现（Guava RateLimiter）：

// 引入Guava依赖
RateLimiter limiter = RateLimiter.create(10.0); // 每秒10个令牌
boolean acquired = limiter.tryAcquire(5, TimeUnit.MILLISECONDS); // 尝试等待5ms获取

Java限流实战：基于Spring Boot的案例

案例1：使用RateLimiter实现API限流

需求：对某个接口限制为每用户每秒最多5次请求。

实现步骤：

添加Guava依赖（或使用Hutool、Redisson等）
使用拦截器或Filter获取用户ID
为每个用户创建独立的RateLimiter

@Component
public class UserRateLimiterInterceptor implements HandlerInterceptor {
    private final Map<String, RateLimiter> userLimiters = new ConcurrentHashMap<>();
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String userId = request.getHeader("X-User-ID");
        RateLimiter limiter = userLimiters.computeIfAbsent(userId, k -> RateLimiter.create(5.0));
        if (!limiter.tryAcquire()) {
            response.setStatus(429); // Too Many Requests
            return false;
        }
        return true;
    }
}

案例2：基于AOP + 注解实现分布式限流（适用微服务）

核心思路：使用Redis作为分布式计数中心,结合Lua脚本保证原子性。

注解定义：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int maxRequests();      // 最大请求数
    int timeWindow();       // 时间窗口（秒）
    String key();           // 限流key（如用户ID）
}

AOP切面实现：

@Aspect
@Component
public class RateLimitAspect {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Around("@annotation(rateLimit)")
    public Object doRateLimit(ProceedingJoinPoint point, RateLimit rateLimit) throws Throwable {
        String key = "ratelimit:" + rateLimit.key();
        long current = System.currentTimeMillis() / 1000;
        long window = current - rateLimit.timeWindow();
        // Lua脚本：清理过期数据，统计窗口内请求数
        String luaScript = 
            "redis.call('zremrangebyscore', KEYS[1], 0, ARGV[1]) " +
            "local count = redis.call('zcard', KEYS[1]) " +
            "if count < tonumber(ARGV[2]) then " +
            "    redis.call('zadd', KEYS[1], ARGV[3], ARGV[3]) " +
            "    redis.call('expire', KEYS[1], ARGV[4]) " +
            "    return true " +
            "end " +
            "return false";
        Boolean acquired = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Boolean.class),
            List.of(key),
            String.valueOf(window), 
            String.valueOf(rateLimit.maxRequests()),
            String.valueOf(current),
            String.valueOf(rateLimit.timeWindow() + 1)
        );
        if (Boolean.TRUE.equals(acquired)) {
            return point.proceed();
        } else {
            throw new RuntimeException("请求过于频繁，请稍后再试");
        }
    }
}