Spring Boot 实现 IP 限流：保障系统稳定性的关键技术

一、引言

在高并发的互联网应用中，系统稳定性面临严峻挑战。恶意攻击、爬虫、以及不合理的接口调用都可能导致系统资源耗尽，影响正常用户体验。为了保障系统的稳定性和可用性，对请求进行限流是至关重要的技术手段。本文将深入探讨如何在 Spring Boot 中实现 IP 限流，包括其原理、使用场景、优缺点、多种实现方式，并给出完整的代码案例，助您构建更加健壮的应用。

二、IP 限流原理：深入解析

IP 限流，顾名思义，就是根据客户端的 IP 地址对请求进行频率限制。其核心在于控制每个 IP 地址在单位时间内允许访问的次数，从而避免单个 IP 大量占用资源，保证系统整体的公平性。以下介绍两种常用的限流算法：

2.1 令牌桶算法 (Token Bucket)

• 工作机制：
  • 系统以恒定速率 ( r ) 向令牌桶中放入令牌。
  • 每个请求需要从令牌桶中获取一个令牌才能被处理。
  • 如果令牌桶为空，则请求被拒绝或等待。
  • 令牌桶具有最大容量 ( b )，当令牌数量达到上限时，新添加的令牌会被丢弃。
• 优点：
  • 平滑突发流量： 允许短时间内突发大量请求，因为令牌桶中可能积累了足够的令牌。
  • 容错性高： 即使短时间内没有请求，令牌也会持续积累，允许后续的请求 burst。
  • 动态适应： 更适合处理动态变化的请求，可以在一定程度上应对流量高峰。

2.2 漏桶算法 (Leaky Bucket)

• 工作机制：
  • 请求被放入漏桶中，漏桶以恒定速率 ( r ) 处理请求。
  • 当请求的速率超过漏桶的处理能力时，多余的请求会在桶中堆积。
  • 如果桶满，则新的请求会被丢弃。
• 优点：
  • 严格控制速率： 能严格控制输出速率，保证请求以固定速度被处理。
  • 平滑输出： 可以将突发流量转化为平滑的输出流量。
• 缺点：
  • 难以应对突发流量： 即使系统资源充足，也无法快速处理突发请求，容易导致请求被拒绝。

2.3 令牌桶与漏桶算法对比

三、IP 限流的使用场景：应用广泛

IP 限流作为一种基础且有效的限流手段，在各种场景中都有广泛的应用：

3.1 API 网关限流

在 API 网关层实现 IP 限流，可以统一管理和控制所有 API 的请求频率，是微服务架构中保护后端服务的关键措施。

3.2 Web 应用安全防护

对登录、注册、找回密码等敏感接口进行 IP 限流，防止暴力破解和恶意注册，增强应用的安全性。

3.3 微服务架构

在微服务架构中，对每个微服务的接口进行 IP 限流，保障服务的稳定性和可用性，防止服务雪崩。

3.4 防止恶意爬虫

限制爬虫程序的访问频率，防止爬虫过度抓取数据，影响正常用户体验。

3.5 控制资源使用

在共享资源的系统中，限制单个 IP 地址的资源使用，确保每个用户都能公平地使用资源。

四、IP 限流的优缺点分析：理性看待

4.1 优点

• 精准控制： 可以针对每个 IP 地址进行精确的请求限制，有效防止单个 IP 的过度请求。
• 实现简单： 相比于其他复杂的限流策略，IP 限流的实现相对简单，不需要复杂的算法和配置。
• 易于维护： 由于每个 IP 的限流规则相对独立，维护和管理起来比较方便。

4.2 缺点

• IP 伪装绕过： 恶意攻击者可以通过 IP 代理或 VPN 等方式伪装自己的 IP 地址，绕过 IP 限流的限制。
• 影响正常用户： 在某些情况下，正常用户可能会因为网络环境等原因被错误地限流，影响用户体验。
• IP 地址池问题： 如果多个用户共享同一个公网 IP 地址，可能会导致正常用户的请求被错误地限流。
• 无法区分用户： IP 限流只能根据 IP 地址进行限制，无法区分不同的用户，可能导致恶意用户利用合法用户的 IP 地址发起攻击。
• 不能应对分布式攻击： 对于分布式拒绝服务（DDoS）攻击，IP 限流只能对单个 IP 进行限制，无法有效应对大量不同 IP 地址的攻击。
• 维护成本： 如果需要对大量 IP 地址进行限流，维护成本可能会比较高，需要考虑使用更高效的存储方案，例如 Redis 或数据库。

五、Spring Boot 实现 IP 限流：代码案例

以下提供两种基于 Spring Boot 的 IP 限流实现方式：

5.1 基于 Guava RateLimiter 的 IP 限流过滤器（推荐）

这种方式使用 Guava 的 RateLimiter 实现令牌桶算法，简单高效，易于配置。

1. 项目搭建：

创建一个 Spring Boot 项目，并添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>31.1-jre</version>
    </dependency>
</dependencies>

2. 创建 RateLimiterService:

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.RateLimiter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RateLimiterService {

    private static final Logger logger = LoggerFactory.getLogger(RateLimiterService.class);

    @Value("${rate.limit.permitsPerSecond:10}") // 默认值 10
    private double permitsPerSecond;

    // 使用 LoadingCache 缓存每个 IP 的 RateLimiter
    private final LoadingCache<String, RateLimiter> rateLimiterCache = CacheBuilder.newBuilder()
            .expireAfterWrite(1, TimeUnit.MINUTES) // 缓存 1 分钟
            .build(new CacheLoader<String, RateLimiter>() {
                @Override
                public RateLimiter load(String ip) {
                    logger.info("Creating RateLimiter for IP: {}, rate: {}", ip, permitsPerSecond);
                    return RateLimiter.create(permitsPerSecond);
                }
            });

    /**
     * 尝试获取令牌
     * @param ip 客户端 IP 地址
     * @return true: 允许访问, false: 限流
     */
    public boolean tryAcquire(String ip) {
        RateLimiter rateLimiter = rateLimiterCache.getUnchecked(ip);
        return rateLimiter.tryAcquire();
    }

}

3. 创建 IP 限流过滤器:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class IpRateLimitFilter extends OncePerRequestFilter {

    private static final Logger logger = LoggerFactory.getLogger(IpRateLimitFilter.class);

    @Autowired
    private RateLimiterService rateLimiterService;

    @Value("${rate.limit.enabled:true}")
    private boolean rateLimitEnabled;

    @Value("${rate.limit.excludePatterns:}") // 排除的URL，用逗号分隔
    private String excludePatterns;


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        if (!rateLimitEnabled) {
            filterChain.doFilter(request, response);
            return; // 如果禁用限流，直接放行
        }

        // 排除不需要限流的URL
        String requestURI = request.getRequestURI();
        if (excludePatterns != null && !excludePatterns.isEmpty()) {
             String[] patterns = excludePatterns.split(",");
             for (String pattern : patterns) {
                if (requestURI.startsWith(pattern.trim())) {
                    filterChain.doFilter(request, response);
                    return;
                 }
             }
        }


        String clientIp = getClientIp(request);

        if (rateLimiterService.tryAcquire(clientIp)) {
            filterChain.doFilter(request, response); // 允许访问
        } else {
            logger.warn("Rate limit exceeded for IP: {}", clientIp);
            response.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
            response.getWriter().write("Too many requests from this IP.");
        }
    }

    private String getClientIp(HttpServletRequest request) {
        String xffHeader = request.getHeader("X-Forwarded-For");
        if (xffHeader == null) {
            return request.getRemoteAddr();
        }
        return xffHeader.split(",")[0];
    }
}

4. 配置过滤器:

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<IpRateLimitFilter> ipRateLimitFilterRegistration(IpRateLimitFilter ipRateLimitFilter) {
        FilterRegistrationBean<IpRateLimitFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(ipRateLimitFilter);
        registration.addUrlPatterns("/*"); // 对所有请求进行限流
        registration.setOrder(1);
        return registration;
    }
}

5. 创建测试控制器:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @GetMapping("/test")
    public String test() {
        return "Hello, this is a test API.";
    }
}

6. application.properties 配置:

# 限流配置
rate.limit.enabled=true
rate.limit.permitsPerSecond=10
rate.limit.excludePatterns=/health,/metrics # 排除的URL

5.2 基于 ConcurrentHashMap 的 IP 限流

import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

@Component
public class IPRequestRateLimiter implements HandlerInterceptor {
    private final int REQUEST_LIMIT = 10;  // 每秒最大请求数
    private final Map<String, AtomicInteger> requestCountsPerIP = new ConcurrentHashMap<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String ipAddress = request.getRemoteAddr();

        // 1. 初始化计数器
        requestCountsPerIP.computeIfAbsent(ipAddress, k -> new AtomicInteger(0));

        // 2. 检查请求是否超限
        if (requestCountsPerIP.get(ipAddress).incrementAndGet() > REQUEST_LIMIT) {
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.getWriter().write("Too many requests from this IP. Please try again later.");
            return false; // 阻止请求
        }
        return true; // 允许请求
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        String ipAddress = request.getRemoteAddr();

        // 3. 请求完成后，减少计数
        requestCountsPerIP.get(ipAddress).decrementAndGet();
    }
}

注意： 此方式只是一个简易的实现，存在时间窗口不精准等问题，生产环境不建议使用.

5.3 测试

启动 Spring Boot 项目，使用工具（如 Postman）模拟不同 IP 地址的请求。当某个 IP 的请求频率超过配置的限制时，会收到 Too many requests from this IP. 的响应。

六、进阶特性：提升 IP 限流的可靠性

• 动态调整限流规则： 可以根据系统负载情况动态调整 permitsPerSecond 的值，实现更灵活的限流策略。可以通过 Spring Cloud Config 等配置中心实现动态更新。
• 黑名单和白名单： 支持黑名单和白名单 IP 地址，对特定的 IP 地址进行特殊处理。可以使用 Redis 等缓存存储黑白名单，并定期更新。
• 监控和告警： 集成监控系统（如 Prometheus、Grafana），实时监控 IP 限流的效果，并设置告警规则，及时发现异常情况。
• 分布式限流： 对于分布式系统，需要使用分布式锁或 Redis 等技术实现分布式限流，保证所有节点使用相同的限流规则。
• 更精细化的限流维度： 可以结合用户 ID、API 接口等维度进行更精细化的限流，例如限制每个用户每天可以访问某个 API 接口的次数。

七、总结

在 Spring Boot 中实现 IP 限流是一种简单而有效的方式来保障系统的稳定性和可用性。通过本文的详细介绍和代码案例，相信您已经掌握了 IP 限流的基本原理和实现方式。在实际应用中，请根据您的具体需求选择合适的限流算法和实现方式，并结合其他安全措施，构建更加健壮的系统。请记住，安全策略应该是全面的，限流只是其中一部分。