在当今互联网后端开发领域，随着业务规模的不断扩大，系统所承载的流量也日益增长。对于基于 Spring Boot3 构建的应用而言，确保 RESTFul 接口在高并发场景下的稳定运行至关重要。而限流，作为一种有效控制流量的手段，能防止系统因过载而崩溃，保障核心业务的正常运转。今天，咱们就深入探讨下如何对 Spring Boot3 的 RESTFul 接口进行限流操作。

限流算法大揭秘

计数器算法

它的原理较为简单。我们将窗口内的时间划分为多个小格子，每个格子代表 1 秒钟，同时每个格子都配备一个计数器，用于统计该秒内访问的请求数量。例如，在 0 到 5 秒这个时间窗口内，若每一秒内有 5 个用户访问，第 5 秒内有 10 个用户访问，那么此时间窗口内访问量就是所有格子计数器累加后的数值，即 15。假设接口设置了时间窗口内访问上限是 20，当时间来到第六秒时，由于 1 秒的格子已退出时间窗口，这个时间窗口内的计数总和就变成了 10，所以在第六秒内可以接收的访问量就是 20 - 10 = 10 个。不过，计数器算法存在明显的弊端，它在时间窗口切换的瞬间，可能会出现流量突增的情况，导致限流效果不够平滑。

漏桶算法

漏桶算法的前半段和令牌桶类似，但操作对象不同。令牌桶是将令牌放入桶里，而漏桶是将访问请求的数据包放到桶里。当桶满时，后续新来的数据包将被丢弃。漏桶算法能保证请求以固定速率流出，从而实现限流效果。但其缺点也很明显，无法应对突发流量，因为不管请求量如何变化，流出速率始终固定。

令牌桶算法

令牌桶算法是目前应用最为广泛的限流算法。顾名思义，它有两个关键角色，即令牌和桶。只有获取到令牌的 Request 才会被处理，其他 Requests 要么排队要么被直接丢弃。令牌桶主要涉及两个过程，一是令牌的生成，系统会以固定速率向桶中添加令牌；二是令牌的获取，每个请求在被处理前，需要从桶中获取一个令牌。如果桶中没有令牌了，请求就无法获取到令牌，进而被限流。令牌桶算法既能应对突发流量，又能保证一定时间内的平均流量在可控范围内，具有较好的灵活性和稳定性。

基于 Guava 的限流实现

Guava 为谷歌开源的一个非常实用的组件，利用这个组件可以帮助开发人员轻松完成常规的限流操作。其限流工具类 ——RateLimiter，便是基于 “令牌桶算法” 来实现限流的。

添加依赖

在项目的 pom.xml 文件中添加 Guava 库的依赖，如下所示：

    com.google.guava
    guava
    32.1.2 - jre

创建限流服务类

创建一个RateLimiterService类，用于实现接口限流的逻辑。示例代码如下：

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.stereotype.Service;

@Service
public class RateLimiterService {
    private RateLimiter rateLimiter;

    public RateLimiterService() {
        // 设置每秒生成的令牌数，可根据需求调整
        rateLimiter = RateLimiter.create(10);
    }

    public boolean tryAcquire() {
        return rateLimiter.tryAcquire();
    }
}

在接口中使用

在 RESTful 接口的实现类中，注入RateLimiterService，并在处理请求前调用tryAcquire方法进行限流检查。示例代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    @Autowired
    private RateLimiterService rateLimiterService;

    @GetMapping("/my - api")
    public String myApi() {
        if (rateLimiterService.tryAcquire()) {
            // 处理请求逻辑
            return "请求处理成功";
        } else {
            return "请求被限流";
        }
    }
}

通过上述步骤，我们就成功利用 Guava 实现了对 Spring Boot3 的 RESTFul 接口的限流操作。这种方式简单直接，对于一些流量规模较小且对性能要求不是特别高的项目来说，是一种不错的选择。

基于 Sentinel 的限流实现

Sentinel 是由阿里巴巴开发的一款强大的流量控制、熔断降级工具，不仅支持限流降级，还具备实时监控、规则动态配置等特性。在 Spring Boot3 项目中，我们可以通过简单的配置快速集成 Sentinel 来实现对 RESTFul 接口的限流。

添加依赖

在 pom.xml 中添加 Sentinel 依赖，如下所示：

    com.alibaba.csp
    sentinel - core
    1.8.6

创建自定义限流注解

示例代码如下：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SentinelLimiter {
    String resourceName();
    int value() default 50;
}

创建自定义 AOP 类

用于处理限流逻辑，示例代码如下：

import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Aspect
@Component
public class SentinelLimiterAop {
    private static void initFlowRule(String resourceName, int limitCount) {
        List rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource(resourceName);
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(limitCount);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }

    @Around("@annotation(com.example.demo.SentinelLimiter)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Method currentMethod = getCurrentMethod(joinPoint);
        if (Objects.isNull(currentMethod)) {
            return null;
        }
        SentinelLimiter sentinelLimiter = currentMethod.getAnnotation(SentinelLimiter.class);
        String resourceName = sentinelLimiter.resourceName();
        int limitCount = sentinelLimiter.value();
        initFlowRule(resourceName, limitCount);
        try (Entry entry = SphU.entry(resourceName)) {
            return joinPoint.proceed();
        } catch (BlockException ex) {
            return "被限流了";
        }
    }

    private Method getCurrentMethod(ProceedingJoinPoint joinPoint) {
        Method[] methods = joinPoint.getTarget().getClass().getMethods();
        Method target = null;
        for (Method method : methods) {
            if (method.getName().equals(joinPoint.getSignature().getName())) {
                target = method;
                break;
            }
        }
        return target;
    }
}

在接口方法上使用注解

例如，@SentinelLimiter(resourceName = "my - api - resource", value = 20)，即可对相应接口进行限流。当接口请求量超过每秒 20 次时，后续请求将被限流，返回 “被限流了” 的提示。

Sentinel 提供了丰富的限流策略和灵活的配置选项，适用于各种复杂的业务场景，能够很好地满足大型项目对流量控制的需求。

基于 Spring Cloud Gateway 的限流（适用于微服务架构）

在微服务架构中，Spring Cloud Gateway 作为 API 网关，为我们提供了便捷的限流功能。它可以对整个微服务系统的入口流量进行统一管控，确保各个微服务实例不会因为流量过大而出现故障。

添加依赖

在 Spring Cloud Gateway 项目的 pom.xml 中添加相关依赖，如下所示：

    org.springframework.cloud
    spring - cloud - starter - gateway


    org.springframework.cloud
    spring-cloud-gateway-filter-factory-ratelimit

配置限流规则

在 application.yml 中配置限流规则，示例如下：

spring:
  cloud:
    gateway:
      routes:
        - id: my - route
          uri: http://localhost:8080
          predicates:
            - Path=/my - api
          filters:
            - name: RateLimiter
              args:
                key - resolver: "#{@ipKeyResolver}"
                redis - rate - limiter.replenishRate: 10
                redis - rate - limiter.burstCapacity: 20

在上述配置中，我们通过Path断言来匹配需要限流的接口路径/my - api。RateLimiter过滤器用于实现限流功能，其中key - resolver指定了限流的键解析器，这里我们使用@ipKeyResolver按 IP 地址进行限流。redis - rate - limiter.replenishRate表示每秒生成的令牌数，即 10 个；redis - rate - limiter.burstCapacity表示令牌桶的最大容量，为 20 个。这意味着每个 IP 地址每秒最多可以有 10 个请求通过，并且可以容忍一定程度的突发流量，最多为 20 个请求。

创建 KeyResolver

用于确定限流的键，例如按 IP 限流，示例代码如下：

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

@Component
public class IpKeyResolver implements KeyResolver {
    @Override
    public Mono resolve(org.springframework.web.server.ServerWebExchange exchange) {
        return Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
    }
}

通过 Spring Cloud Gateway 进行限流，能够在微服务架构的入口处对流量进行统一管理，有效地保护各个微服务实例，提高整个系统的稳定性和可靠性。

综上所述，在 Spring Boot3 项目中，我们有多种方式可以对 RESTFul 接口进行限流操作，每种方式都有其适用的场景和特点。开发人员可以根据项目的实际需求、流量规模、架构复杂度等因素，选择合适的限流方案，以确保系统在高并发环境下能够稳定、高效地运行。