Springboot集成Sentinel 组件实现基本限流功能(快速入门)

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.6</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.6</version>
</dependency>

@Component
public class FlowLimitInterceptor implements HandlerInterceptor {
    private static final Logger log = LoggerFactory.getLogger(FlowLimitInterceptor.class);
    private final ObjectMapper objectMapper;
    public FlowLimitInterceptor(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    } 
     // SmallNovel 项目所有的资源，名称只用于标识，建议易于理解即可
    private static final String SMALL_NOVEL_RESOURCE = "SmallNovelResource";
	//静态代码块使规则在类加载时就初始化了
    static {
        // 接口限流规则：所有的请求，限制每秒最多只能通过 2000 个，超出限制匀速排队
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(SMALL_NOVEL_RESOURCE);
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置 QPS 限流 2000.
        rule1.setCount(2000);
        rule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER);
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
        // 接口防刷规则 1：所有的请求，限制每个 IP 每秒最多只能通过 50 个，超出限制直接拒绝
        ParamFlowRule rule2 = new ParamFlowRule(SMALL_NOVEL_RESOURCE)
                .setParamIdx(0)
                .setCount(50);
        // 接口防刷规则 2：所有的请求，限制每个 IP 每分钟最多只能通过 1000 个，超出限制直接拒绝
        ParamFlowRule rule3 = new ParamFlowRule(SMALL_NOVEL_RESOURCE)
                .setParamIdx(0)
                .setCount(1000)
                .setDurationInSec(60);
        ParamFlowRuleManager.loadRules(Arrays.asList(rule2, rule3));
    }
    @Override
    public boolean preHandle(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler) throws Exception {
        String ip = IpUtils.getRealIp(request);
        Entry entry = null;
        try {
            entry = SphU.entry(SMALL_NOVEL_RESOURCE, EntryType.IN, 1, ip);
            return HandlerInterceptor.super.preHandle(request, response, handler);
        } catch (BlockException ex) {
            log.info("IP:{}被限流了！", ip);
            response.setCharacterEncoding(StandardCharsets.UTF_8.name());
            response.setContentType(MediaType.APPLICATION_JSON_VALUE);
            response.getWriter()
                    .write(错误信息);
        } finally {
            if (entry != null) {
                entry.exit(1, ip);
            }
        }
        return false;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    private final FlowLimitInterceptor flowLimitInterceptor;
    public WebConfig(FlowLimitInterceptor flowLimitInterceptor) {
        this.flowLimitInterceptor = flowLimitInterceptor; }
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 流量限制拦截器
        registry.addInterceptor(flowLimitInterceptor)
                .addPathPatterns("/**")
                .order(0);
}
}

@Configuration
public class SentinelAspectConfig {
    @Bean
    public SentinelResourceAspect sentinelResourceAspect() {
        return new SentinelResourceAspect();
    }
}

@Service
public class OrderService {
    @SentinelResource(
        value = "createOrder", 
        blockHandler = "handleFlowBlock",
        blockHandlerClass = OrderServiceBlockHandler.class
    )
    public String createOrder() {
        // 业务逻辑
        return "订单创建成功";
    }
    // 异常处理函数（可选）
    public String handleException(Throwable ex) {
        return "服务异常: " + ex.getMessage();
    }
}

public class OrderServiceBlockHandler {
    // 流控处理函数需满足：
    // 1. public static修饰
    // 2. 返回类型与原方法相同
    // 3. 参数列表包含原方法所有参数 + BlockException
    public static String handleFlowBlock(BlockException ex) {
        return "请求过于频繁，请稍后重试！触发规则: " + ex.getRule().getResource();
    }
}

@Component
public class SentinelRuleInitializer {
    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("createOrder");   // 资源名称
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // QPS限流模式
        rule.setCount(2);                 // 阈值：2次/秒
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); 
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

List<DegradeRule> degradeRules = new ArrayList<>();
DegradeRule degradeRule = new DegradeRule();
degradeRule.setResource("createOrder");
degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT); // 异常数模式
degradeRule.setCount(5); // 异常数阈值
degradeRule.setTimeWindow(30); // 熔断时长(秒)
degradeRules.add(degradeRule);
DegradeRuleManager.loadRules(degradeRules);

# 下载控制台JAR包
wget https://github.com/alibaba/Sentinel/releases/download/1.8.6/sentinel-dashboard-1.8.6.jar
# 启动控制台（默认端口8080）
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -jar sentinel-dashboard-1.8.6.jar

# Linux/macOS
export SENTINEL_LOG_DIR=/var/log/sentinel
# Windows
set SENTINEL_LOG_DIR=C:\logs\sentinel