Sentinel限流入门指南-原创手记-慕课网

概述

Sentinel是一款由阿里巴巴开源的高可用防护组件，主要用于分布式服务架构中进行流量控制、服务熔断和授权等功能，确保服务的稳定性和高可用性。本文将详细介绍Sentinel的核心功能和Sentinel限流的基本配置，并通过具体的应用案例来展示如何使用Sentinel进行限流操作，涵盖多种限流模型和规则。Sentinel限流的关键在于合理设置规则，以保护系统免受过大的流量冲击。

1. Sentinel简介

Sentinel 是阿里巴巴开源的一款面向分布式服务架构的高可用防护组件。其主要功能是提供服务容错、流量控制和授权等功能，以保护服务的稳定性。Sentinel 提供了丰富的功能，并且能够与主流的微服务框架很好地集成，使得开发者能够方便地进行限流、降级和授权等操作。

1.1 什么是Sentinel

Sentinel 是一个轻量级的、高性能的服务保护组件，它能够帮助开发人员在复杂的分布式环境中进行流量控制、限流、降级和授权。Sentinel 的设计目标是提供实时监控和快速响应的能力，以确保服务的高可用性和稳定性。Sentinel 的核心功能包括：

流量控制：保护服务免受过大的流量冲击。
服务熔断：当服务出现故障时，自动降低调用等级，避免雪崩效应。
授权：提供灵活的黑白名单功能，以控制服务的访问。
系统保护：防止系统负载过重，通过设置系统维度的阈值来避免系统故障。

1.2 Sentinel的核心功能

Sentinel 的核心功能可以分为以下几个方面：

流量控制
- 模型化流量控制：Sentinel 提供了多种流量控制模型，包括直接、关联、链路和系统等，以满足不同的流量控制需求。
- 实时监控和统计：Sentinel 可以实时监控服务的流量情况，并提供详细的统计信息，以便开发人员进行分析。
- 精确控制：Sentinel 支持多种规则，可以精确地控制流量的流入和流出。
服务熔断
- 实时检测和熔断：当服务出现故障时，Sentinel 可以实时检测并自动进行熔断，避免服务雪崩效应。
- 容错机制：Sentinel 提供了多种容错机制，以确保服务的高可用性。
- 自动恢复：当服务恢复正常后，Sentinel 可以自动恢复熔断的状态。
授权
- 黑白名单控制：Sentinel 提供了黑白名单功能，可以灵活地控制服务的访问权限。
- 过滤规则：Sentinel 支持多种过滤规则，可以根据不同的条件进行过滤。
系统保护
- 系统维度的阈值设置：Sentinel 提供了系统维度的阈值设置，以防止系统负载过重。
- 实时监控和报警：Sentinel 可以实时监控系统状态，并在超出阈值时进行报警。
- 多维度保护：Sentinel 支持多种维度的保护，如 CPU 使用率、系统负载等。

1.3 示例代码

流量控制

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class FlowControlExample {
    @SentinelResource(value = "flowControlResource", blockHandler = "handleBlock")
    public void flowControl() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被限流");
    }

    public static void main(String[] args) {
        // 初始化 Sentinel
        Sentinel.init();

        // 创建限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("flowControlResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));

        // 调用服务
        FlowControlExample example = new FlowControlExample();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(example::flowControl).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

服务熔断

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class CircuitBreakerExample {
    @SentinelResource(value = "circuitBreakerResource", blockHandler = "handleBlock")
    public void circuitBreaker() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被熔断");
    }

    public static void main(String[] args) {
        // 初始化 Sentinel
        Sentinel.init();

        // 创建限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("circuitBreakerResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));

        // 调用服务
        CircuitBreakerExample example = new CircuitBreakerExample();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(example::circuitBreaker).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

授权

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class AuthorizationExample {
    @SentinelResource(value = "authorizationResource", blockHandler = "handleBlock")
    public void authorization() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被授权控制");
    }

    public static void main(String[] args) {
        // 初始化 Sentinel
        Sentinel.init();

        // 创建限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("authorizationResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));

        // 调用服务
        AuthorizationExample example = new AuthorizationExample();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(example::authorization).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

系统保护

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.system.SystemManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

public class SystemProtectionExample {
    @SentinelResource(value = "systemProtectionResource", blockHandler = "handleBlock")
    public void systemProtection() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被系统保护");
    }

    public static void main(String[] args) {
        // 初始化 Sentinel
        Sentinel.init();

        // 创建系统规则
        SystemRule systemRule = new SystemRule();
        systemRule.setResource("systemProtectionResource");
        systemRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        systemRule.setCount(10);

        // 添加规则到规则管理器中
        SystemRuleManager.loadRules(Collections.singletonList(systemRule));

        // 启动系统监控
        SystemManager.start();

        // 调用服务
        SystemProtectionExample example = new SystemProtectionExample();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(example::systemProtection).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

2. 限流的基本概念

限流是分布式系统中常见的技术之一，用于保护系统免受过大的流量冲击。限流的核心思想是限制请求的访问速率，以确保系统的稳定性和可用性。

2.1 什么是限流

限流是指在系统中设置一定的流量上限，当流量超过这个上限时，系统会拒绝新的请求。限流可以基于多种因素进行控制，如时间窗口、请求速率、并发数等。常见的限流算法包括令牌桶算法和漏桶算法等。

2.2 为什么要使用限流

限流的目的在于保护系统免受过大的流量冲击，从而确保系统的稳定性和可用性。如果不进行限流，当系统突然接收到大量的请求时，可能会导致系统过载，从而引起服务的不稳定甚至宕机。通过限流，可以有效地控制流量，避免系统过载，确保服务的稳定性。

限流的具体应用场景包括：

防止流量突增：当系统突然接收到大量的请求时，可以通过限流来控制请求的访问速率，避免系统过载。
保护后端服务：通过限流可以保护后端服务，避免后端服务因为处理大量的请求而崩溃。
防止恶意攻击：通过限流可以防止恶意攻击，例如 DDoS 攻击。
资源优化利用：通过限流可以合理分配资源，确保资源的优化利用。

2.3 限流算法

令牌桶算法

令牌桶算法是一种常用的限流算法，它通过设定一个桶的容量和令牌生成速率来控制请求的访问速率。当桶中令牌数量达到规定值时，请求通过，否则拒绝。

public class TokenBucket {
    private int capacity; // 桶的容量
    private int currentTokens; // 当前桶中的令牌数量
    private int fillRate; // 令牌生成速率

    public TokenBucket(int capacity, int fillRate) {
        this.capacity = capacity;
        this.currentTokens = capacity;
        this.fillRate = fillRate;
    }

    public synchronized boolean consume(int permits) {
        if (permits <= currentTokens) {
            currentTokens -= permits;
            return true;
        } else {
            return false;
        }
    }

    public synchronized void refill(int permits) {
        currentTokens = Math.min(capacity, currentTokens + permits);
    }
}

漏桶算法

漏桶算法也是一种常用的限流算法，它通过设定一个固定的流出速率来控制请求的访问速率。当桶中的令牌数量达到规定值时，请求通过，否则拒绝。

public class LeakyBucket {
    private int capacity; // 桶的容量
    private int currentTokens; // 当前桶中的令牌数量
    private long lastRefillTime; // 上次填充令牌的时间

    public LeakyBucket(int capacity, long refillInterval) {
        this.capacity = capacity;
        this.currentTokens = capacity;
        this.lastRefillTime = System.currentTimeMillis();
    }

    public synchronized boolean consume(int permits) {
        currentTimeMillis();
        long currentTime = System.currentTimeMillis();
        int tokensToRefill = (int) ((currentTime - lastRefillTime) / refillInterval);
        currentTokens += tokensToRefill;
        currentTokens = Math.min(capacity, currentTokens);
        lastRefillTime = currentTime;

        if (permits <= currentTokens) {
            currentTokens -= permits;
            return true;
        } else {
            return false;
        }
    }
}

3. Sentinel限流的基本配置

本节将详细介绍如何下载与安装 Sentinel，并提供基本的配置步骤。

3.1 下载与安装Sentinel

Sentinel 的下载与安装非常简单，可以通过 Maven 或者直接下载 JAR 包的方式进行。

Maven 依赖

如果使用 Maven 管理项目，可以在 pom.xml 文件中添加如下依赖：

<dependencies>
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-core</artifactId>
        <version>1.8.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-mysql</artifactId>
        <version>1.8.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-transport-simple</artifactId>
        <version>1.8.2</version>
    </dependency>
</dependencies>

JAR 包下载

如果不想使用 Maven 管理项目，可以手动下载 Sentinel 的 JAR 包。可以从 Sentinel 的 GitHub 仓库中下载：

https://github.com/alibaba/Sentinel/releases

下载完成后，将 JAR 包添加到项目的依赖路径中。

3.2 基本配置步骤

配置 Sentinel 可以分为以下几个步骤：

3.2.1 初始化 Sentinel

在初始化 Sentinel 时，需要创建一个 FlowRuleManager 实例，并初始化一些基本的规则。以下是一个简单的初始化示例：

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class SentinelInitializer implements InitFunc {
    @Override
    public void init() {
        // 创建一个限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("testResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

3.2.2 配置启动参数

在启动应用时，可以通过配置启动参数来启动 Sentinel。例如，在 application.properties 文件中添加以下配置：

spring.cloud.sentinel.transport.port=8719
spring.cloud.sentinel.transport.server.port=8719
spring.cloud.sentinel.transport.server.ip=localhost

3.2.3 启动并运行应用

启动应用后，Sentinel 将自动进行初始化，并开始监控和保护服务。可以通过访问 http://localhost:8719 来查看 Sentinel 的控制台。

4. Sentinel限流规则详解

Sentinel 提供了多种限流规则，可以灵活地控制流量的流入和流出。本节将详细介绍两种常见的限流规则：流量控制规则和自适应限流规则。

4.1 流量控制规则

流量控制规则是 Sentinel 中最基本的限流规则，可以细分为直接、关联、链路和系统等模型。这些模型可以满足不同的限流需求。

4.1.1 直接模型

直接模型是最简单的模型，它直接对资源进行限流。以下是一个直接模型的示例：

import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class DirectFlowRuleExample {
    public static void main(String[] args) {
        // 创建一个直接模型的限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("directResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

4.1.2 关联模型

关联模型用于对多个资源进行关联限流。当一个资源达到限流阈值时，所有相关的资源都会被限流。以下是一个关联模型的示例：

import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class AssociatedFlowRuleExample {
    public static void main(String[] args) {
        // 创建一个关联模型的限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("associatedResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        rule.setLimitApp("default");

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

4.1.3 链路模型

链路模型用于对服务之间的调用链路进行限流。例如，当一个服务调用另一个服务时，可以通过链路模型来进行限流。以下是一个链路模型的示例：

import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class LinkFlowRuleExample {
    public static void main(String[] args) {
        // 创建一个链路模型的限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("linkResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

4.1.4 系统模型

系统模型用于对系统整体的负载进行限流。例如，当系统的 CPU 使用率超过某个阈值时，可以通过系统模型来进行限流。以下是一个系统模型的示例：

import com.alibaba.csp.sentinel.slots.system.SystemManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

public class SystemFlowRuleExample {
    public static void main(String[] args) {
        // 创建一个系统模型的限流规则
        SystemRule rule = new SystemRule();
        rule.setResource("systemResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        // 添加规则到规则管理器中
        SystemRuleManager.loadRules(Collections.singletonList(rule));

        // 启动系统监控
        SystemManager.start();
    }
}

4.2 自适应限流规则

自适应限流规则是一种更加智能的限流规则，它能够根据系统的实时负载情况自动调整限流阈值。以下是一个自适应限流规则的示例：

import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class AdaptiveFlowRuleExample {
    public static void main(String[] args) {
        // 创建一个自适应限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("adaptiveResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

5. Sentinel限流实战案例

本节将通过具体的应用案例来展示如何使用 Sentinel 进行限流。我们将分别介绍简单的应用案例和复杂场景案例。

5.1 简单应用案例

假设我们需要对一个简单的服务进行限流，以保护服务免受过大的流量冲击。我们可以使用 Sentinel 的直接模型来进行限流。

5.1.1 示例代码

以下是一个简单的服务限流示例：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class SimpleService {
    @SentinelResource(value = "simpleResource", blockHandler = "handleBlock")
    public void simpleService() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被限流");
    }

    public static void main(String[] args) {
        // 创建限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("simpleResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));

        // 初始化 Sentinel
        Sentinel.init();

        // 调用服务
        SimpleService service = new SimpleService();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(service::simpleService).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

5.1.2 运行结果

运行上述代码后，可以看到当请求数量超过 10 时，服务会被限流，并输出 "服务被限流" 的信息。

5.2 复杂场景案例

假设我们需要对一个复杂的分布式系统进行限流，以保护系统免受过大的流量冲击。我们可以使用 Sentinel 的多种限流模型来进行限流。

5.2.1 示例代码

以下是一个复杂的分布式系统限流示例：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemManager;

import java.util.Collections;

public class ComplexService {
    @SentinelResource(value = "complexResource", blockHandler = "handleBlock")
    public void complexService() {
        System.out.println("访问服务");
    }

    public void handleBlock(BlockException exception) {
        System.out.println("服务被限流");
    }

    public static void main(String[] args) {
        // 创建直接模型的限流规则
        FlowRule directRule = new FlowRule();
        directRule.setResource("directResource");
        directRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        directRule.setCount(10);

        // 创建关联模型的限流规则
        FlowRule associatedRule = new FlowRule();
        associatedRule.setResource("associatedResource");
        associatedRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        associatedRule.setCount(10);

        // 创建链路模型的限流规则
        FlowRule linkRule = new FlowRule();
        linkRule.setResource("linkResource");
        linkRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        linkRule.setCount(10);

        // 创建系统模型的限流规则
        SystemRule systemRule = new SystemRule();
        systemRule.setResource("systemResource");
        systemRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        systemRule.setCount(10);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(directRule));
        FlowRuleManager.loadRules(Collections.singletonList(associatedRule));
        FlowRuleManager.loadRules(Collections.singletonList(linkRule));
        SystemRuleManager.loadRules(Collections.singletonList(systemRule));

        // 启动系统监控
        SystemManager.start();

        // 初始化 Sentinel
        Sentinel.init();

        // 调用服务
        ComplexService service = new ComplexService();
        for (int i = 0; i < 20; i++) {
            Entry entry = null;
            try {
                entry = Sentinel.wrap(service::complexService).invoke();
            } catch (BlockException e) {
                System.out.println("请求被限流");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }
}

5.2.2 运行结果

运行上述代码后，可以看到当请求数量超过阈值时，服务会被限流，并输出 "服务被限流" 的信息。同时，不同模型的规则会根据不同的条件进行限流。

6. Sentinel限流的常见问题与解决方案

在使用 Sentinel 进行限流时，可能会遇到一些常见的问题。本节将介绍一些常见的问题及其解决方案。

6.1 常见问题

限流规则不生效：检查是否正确配置了限流规则，确保规则已经加载到规则管理器中。
限流规则冲突：检查是否有多个规则同时作用于同一个资源，确保规则之间没有冲突。
限流规则误触发：检查规则的阈值设置是否合理，避免误触发。
限流规则加载失败：检查依赖配置是否正确，确保 JAR 包已经添加到项目中。

6.2 解决方案概述

检查规则配置：确保规则配置正确，包括资源名称、限流类型、阈值等。
调试和日志：通过调试和查看日志来定位问题，确保规则的正常加载和执行。
优化阈值设置：根据系统的实际情况调整阈值设置，避免误触发。
依赖和环境检查：确保依赖配置正确，环境设置正常。

示例代码

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.init.InitFunc;

public class SentinelInitializer implements InitFunc {
    @Override
    public void init() {
        // 创建一个限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("testResource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(1000);

        // 添加规则到规则管理器中
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

通过以上解决方案，可以有效解决 Sentinel 限流中常见的问题，确保限流规则能够正常工作。