大家好，欢迎来到IT知识分享网。

1. 准备工作

创建 SpringBoot 应用，命名为 Sentinel-Quick-start

1.1. Maven 依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.0</version>
</dependency>

1.2. Controller 层

@Controller
public class TestController { 
   

    @RequestMapping(path = { 
   "/hello"}, method = RequestMethod.GET)
    @ResponseBody
    public String hello() { 
   
        try { 
   
        	// 设置一个资源名称为 Hello
            Entry ignored = SphU.entry("Hello");
            System.out.println("Hello Sentinel");
            return "Hello Sentinel";
        } catch (BlockException e) { 
   
            System.out.println("系统繁忙，请稍后");
            e.printStackTrace();
            return "系统繁忙，请稍后";
        }
    }

    /** * 使用代码编写流控规则，项目中不推荐使用，这是硬编码方式 * * 注解 @PostConstruct 的含义是：本类构造方法执行结束后执行 */
    @PostConstruct
    public void initFlowRule() { 
   
        /* 1.创建存放限流规则的集合 */
        List<FlowRule> rules = new ArrayList<>();
        /* 2.创建限流规则 */
        FlowRule rule = new FlowRule();
        /* 定义资源，表示 Sentinel 会对哪个资源生效 */
        rule.setResource("Hello");
        /* 定义限流的类型(此处使用 QPS 作为限流类型) */
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        /* 定义 QPS 每秒通过的请求数 */
        rule.setCount(2);
        /* 3.将限流规则存放到集合中 */
        rules.add(rule);
        /* 4.加载限流规则 */
        FlowRuleManager.loadRules(rules);
    }
}

1.3. 测试运行

1.4. 快速刷新页面

2. 搭建 Sentinel 控制台

下载 Sentinel 控制台 jar 包：https://github.com/alibaba/Sentinel/releases

启动 Sentinel 控制台，如下图所示

java -Dserver.port=9000 -jar sentinel-dashboard-1.8.0.jar

访问 Sentinel 控制台：http://127.0.0.1:9000/

输入用户名和密码：都是 Sentinel

3. SpringBoot 整合 Sentinel

3.1. Maven 依赖

<!-- Sentinel本地应用接入控制台 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.0</version>
</dependency>

3.2. 在 idea 中设置本地应用的 JVM 启动参数

-Dcsp.sentinel.dashboard.server=127.0.0.1:9000   Sentinel控制台的地址和端口号
-Dproject.name=Sentinel-Quick-Start				本地应用在控制台中的名称

3.3. 运行测试

第一次查看控制台，需要先访问一次被限流控制的接口，否则控制台中没有东西

3.4. 设置流控规则

3.4.1. 修改上述 TestController 类

删除使用代码编写的流控规则，项目中不推荐使用，这是硬编码方式

@Controller
public class TestController { 
   

    @RequestMapping(path = { 
   "/hello"}, method = RequestMethod.GET)
    @ResponseBody
    public String hello() { 
   
        try { 
   
            Entry ignored = SphU.entry("Hello");
            System.out.println("Hello Sentinel");
            return "Hello Sentinel";
        } catch (BlockException e) { 
   
            System.out.println("系统繁忙，请稍后");
            e.printStackTrace();
            return "系统繁忙，请稍后";
        }
    }
}

3.4.2. 启动上述项目，如下操作

3.4.3. 新增流控规则

3.4.4. 新增成功后查看

3.4.5. 测试流控规则

3.4.6. 快速刷新页面时

4. SpringBoot 整合 Sentinel 实现限流熔断

实现方式有以下几种

• 抛出异常的方式
• 返回布尔值的方式
• 异步调用支持
• 注解方式（推荐）

4.1. 抛出异常的方式定义资源示例

使用这种方式当资源发生限流后会抛出 BlockException 异常。这个时候可以捕获异常，进行限流之后的逻辑处理，关键代码如下

@RequestMapping(path = { 
   "/hello"}, method = RequestMethod.GET)
@ResponseBody
public String hello() { 
   

    try { 
   
        Entry ignored = SphU.entry("Hello");
        System.out.println("Hello Sentinel");
        return "Hello Sentinel";
    } catch (BlockException e) { 
   
        System.out.println("系统繁忙，请稍后");
        e.printStackTrace();
        return "系统繁忙，请稍后";
    }
}

4.2. 返回布尔值的方式定义资源示例

使用的 API 为 SphO，限流后返回的值为 boolean 类型。注意：SphO.entry 必须和 SphO.exit 成对出现 否则会报错

@GetMapping("/boolean")
public boolean returnBoolean() { 
   

    // 使用限流规则
    if (SphO.entry("Sentinel-boolean")){ 
   
         try { 
   
             System.out.println("Hello Sentinel");
             return true;
          }finally { 
   
          	  // 限流的出口
              SphO.exit();
          }
    } else { 
   
        // 限流后进行的操作
        System.out.println("系统繁忙,请稍后再试");
        return false;
    }
}

4.3. 异步调用支持示例

在启动类中添加 @EnableAsync，表示 SpringBoot 项目开启异步调用支持

@SpringBootApplication
@EnableAsync
public class SentinelQuickStartApplication { 
   

    public static void main(String[] args) { 
   
        SpringApplication.run(SentinelQuickStartApplication.class, args);
    }
}

4.3.1. 创建 AsyncService 编写异步调用的方法

@Service
public class AsyncService { 
   

    // Async表示方法为异步调用
    @Async
    public void hello(){ 
   
        System.out.println("异步调用开始======");
        try { 
   
            Thread.sleep(5000);
        } catch (InterruptedException e) { 
   
            e.printStackTrace();
        }
        System.out.println("异步调用结束=====");
    }
}

4.3.2. Controller层

@Autowired
private AsyncService asyncService;

@GetMapping("/async")
public void async() { 
   

	// 1.进行限流控制
    AsyncEntry asyncEntry = null;
    try { 
   
    	asyncEntry = SphU.asyncEntry("Sentinel_Async"); // 限流入口
        asyncService.hello(); // 异步调用方法
        System.out.println("异步测试");
    } catch (BlockException e) { 
   
        e.printStackTrace();
        System.out.println("系统繁忙请稍后再试");
    } finally { 
   
        if (asyncEntry != null) { 
   
        	asyncEntry.exit(); // 限流出口
        }
	}
}

4.4. 注解方式定义资源示例

Sentinel 支持通过 @SentinelResource 注解来定义资源，并配置 blockHandler 函数来进行限流之后的处理

4.4.1. Maven 依赖

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

4.4.2. AspectJ 的配置类

@Configuration
public class SentinelAspectConfiguration { 
   

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

4.4.3. Controller 层

@Controller
public class Test2Controller { 
   

    // value：资源名称 blockHandler：设置限流或降级处理的类
    @SentinelResource(value = "sentinel_springcloud", blockHandler = "exceptionHandler")
    @ResponseBody
    @RequestMapping(path = "/ann", method = RequestMethod.GET)
    public String ann() { 
   
        // 使用限流规则
        return "Hello Sentinel";
    }

    public String exceptionHandler(@NotNull BlockException e) { 
   
        e.printStackTrace();
        return "系统繁忙，请稍后再试";
    }
}