CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Spring Cloud 中断路器 Circuit Breaker 的应用由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

环境：Springboot2.3.12.RELEASE + 。

cloud-netflix-hystrix2.2.10.RELEASE 。

简介

SpringCloud Circuit breaker(断路器)提供了跨不同断路器实现的抽象。它提供了在应用程序中使用的一致API，允许开发人员选择最适合应用程序需要的断路器实现.

支持的断路器类型：

• Netfix Hystrix
• Resilience4J
• Sentinel
• Spring Retry

核心概念

要在代码中创建断路器(circuit breaker)，可以使用断路器工厂API。当您在类路径中包含Spring Cloud Circuit Breaker starter时，将自动创建一个实现此API的bean。下面给出了使用此API的一个非常简单的示例:

1. @Service
2. public static class DemoService {
3. private RestTemplate rest;
4. private CircuitBreakerFactory cbFactory;
6. public DemoService(RestTemplate rest, CircuitBreakerFactory cbFactory) {
7. this.rest = rest;
8. this.cbFactory = cbFactory;
9. }
11. public String slow() {
12. // 通过默认的CircuitBreakerFactory工厂创建一个指定id（名称）的断路器
13. // run方法是实际执行你的业务方法，第二个参数throwable 是当发生异常或者是执行超时
14. // 执行的回退（降级）处理
15. return cbFactory.create("slow").run(() -> rest.getForObject("/slow", String.class), throwable -> "fallback");
16. }
17. }

项目配置

通过引入下面不同依赖来确定使用具体的那个断路器:

• Hystrix - org.springframework.cloud:spring-cloud-starter-netflix-hystrix
• Resilience4J - org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j
• Reactive Resilience4J - org.springframework.cloud:spring-cloud-starter-circuitbreaker-reactor-resilience4j
• Spring Retry - org.springframework.cloud:spring-cloud-starter-circuitbreaker-spring-retry
• Sentinal - org.springframework.cloud:spring-cloud-starter-circuitbreaker-sentinal

以上5种断路器是不同的实现方式，根据需要引入即可.

示例

这里以Hystrix为例来使用 。

引入依赖

2. org.springframework.cloud
3. spring-cloud-starter-netflix-hystrix
4. 2.2.10.RELEASE

定义具有熔断功能的服务

1. @Service
2. public class DemoService {
4. private RestTemplate rest;
5. // 注入系统默认的实现
6. private CircuitBreakerFactory cbFactory;
8. public DemoService(RestTemplate rest, CircuitBreakerFactory cbFactory) {
9. this.rest = rest;
10. this.cbFactory = cbFactory;
11. }
13. public String slow() {
14. // 使用系统默认的实现创建断路器进行业务的处理
15. return cbFactory.create("slow").run(() -> rest.getForObject("http://localhost:8080/demos/slow", String.class), throwable -> "fallback");
16. }
18. public String slow2() {
19. // 使用自定义的断路器工厂进行业务的处理
20. return cbf().create("demo-slow").run(() -> rest.getForObject("http://localhost:8080/demos/slow", String.class), throwable -> "fallback");
21. }
23. // 可以将这个定义为Bean来覆盖系统默认的实现，在系统默认的实现上有条件限定
24. private CircuitBreakerFactory cbf() {
25. HystrixCircuitBreakerFactory cbf = new HystrixCircuitBreakerFactory() ;
26. // 配置线程池
27. HystrixThreadPoolProperties.Setter threadPoolProperties = HystrixThreadPoolProperties.Setter() ;
28. threadPoolProperties.withCoreSize(5)
29. .withKeepAliveTimeMinutes(5)
30. .withMaxQueueSize(Integer.MAX_VALUE)
31. .withQueueSizeRejectionThreshold(1000) ;
32. // 配置默认的执行行为属性
33. HystrixCommandProperties.Setter commandProperties = HystrixCommandProperties.Setter() ;
34. commandProperties.withCircuitBreakerEnabled(true)
35. // 当请求超过了3s那么断路器就会工作进行回退（降级处理），执行上面run方法中的第二个参数
36. .withExecutionTimeoutInMilliseconds(3000)
37. .withRequestCacheEnabled(true)
38. // 隔离策略有两种THREAD，SEMAPHORE
39. // THREAD: 避免线程被阻塞
40. // SEMAPHORE: 适合高并发限流处理；因为线程池的方式一般不会创建过多的线程
41. // 线程是有限的，在高并发情况下是没法满足响应处理的。
42. .withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD);
44. // 将其加入到集合中，为不同的服务创建不同的配置
45. cbf.configure(builder -> {
46. builder.commandProperties(commandProperties).groupName("demo") ;
47. }, "demo-slow");
49. // 当默认的id不存在时使用这默认的配置
50. cbf.configureDefault(id -> {
51. HystrixCommand.Setter setter = HystrixCommand.Setter
52. .withGroupKey(HystrixCommandGroupKey.Factory.asKey("demo")) // 服务分组，大的模块
53. .andCommandKey(HystrixCommandKey.Factory.asKey("demo-slow")) // 服务标识（具体服务分组中的某一个子的服务），子模块
54. .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("demo-pools")) // 线程池名称
55. .andThreadPoolPropertiesDefaults(threadPoolProperties) // 线程池相关配置
56. .andCommandPropertiesDefaults(commandProperties) ; // 执行时相关属性配置
57. return setter ;
58. });
59. return cbf ;
60. }
62. }

Controller接口

1. @RestController
2. @RequestMapping("/demos")
3. public class DemoController {
5. @Resource
6. private DemoService demoService ;
8. @GetMapping("/index")
9. public Object index() {
10. return demoService.slow2() ;
11. }
13. @GetMapping("/slow")
14. public Object slow() {
15. try {
16. TimeUnit.SECONDS.sleep(5) ;
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. return "slow" ;
21. }
23. }

原理

CircuitBreakerFactory#create方法创建了CircuitBreaker实例.

根据当前的CLASSPATH我们使用的是Hystrix，那么这里使用的工厂就是:

HystrixCircuitBreakerFactory类 。

1. public class HystrixCircuitBreakerFactory extends CircuitBreakerFactory {

泛型参数：Setter就是用来配置Hystrix相关配置信息的(这里主要用来CommandKey与Setter进行绑定)，HystrixConfigBuilder用来构建 HystrixCommand.Setter对象.

当执行HystrixCircuitBreakerFactory#configure方法时:

1. public abstract class AbstractCircuitBreakerFactory > {
2. private final ConcurrentHashMap configurations = new ConcurrentHashMap<>();
3. public void configure(Consumer consumer, String... ids) {
4. for (String id : ids) {
5. // 构建一个Builder对象
6. CONFB builder = configBuilder(id);
7. // 这里通过builder(HystrixConfigBuilder)对象来应用Consumer中编写的配置信息
8. consumer.accept(builder);
9. // 构建HystrixCommand.Setter 对象
10. CONF conf = builder.build();
11. // 最后将通过id 与 Setter对象绑定key=value存入Map集合中
12. getConfigurations().put(id, conf);
13. }
14. }
15. // 该方法在子类HystrixCircuitBreakerFactory中实现
16. protected abstract CONFB configBuilder(String id);
17. }

断路器具体的子类实现

HystrixCircuitBreakerFactory 。

1. // 子类继承的父类中的泛型：第一个泛型参数：需要构建什么样的一个配置，第二个泛型参数：通过谁来构建第一个泛型参数配置
2. public class HystrixCircuitBreakerFactory extends CircuitBreakerFactory {
3. public HystrixConfigBuilder configBuilder(String id) {
4. return new HystrixConfigBuilder(id);
5. }
6. public static class HystrixConfigBuilder extends AbstractHystrixConfigBuilder {
7. public HystrixConfigBuilder(String id) {
8. super(id);
9. }
10. // 从这里也看出来最终Builder就是用来构建Setter对象用
11. @Override
12. public HystrixCommand.Setter build() {
13. return HystrixCommand.Setter.withGroupKey(getGroupKey())
14. .andCommandKey(getCommandKey())
15. .andCommandPropertiesDefaults(getCommandPropertiesSetter());
16. }
17. }
18. }

断路器工厂有了，接下来就是通过工厂创建具体的断路器对象了.

通过上面的代码执行cbf().create("demo-slow")方法时执行了什么？

1. public class HystrixCircuitBreakerFactory extends CircuitBreakerFactory {
2. private Function defaultConfiguration = id -> HystrixCommand.Setter
3. .withGroupKey(HystrixCommandGroupKey.Factory.asKey(getClass().getSimpleName()))
4. .andCommandKey(HystrixCommandKey.Factory.asKey(id));
5. public HystrixCircuitBreaker create(String id) {
6. // 通过上面分析最终所有的Hystrix的Setter会与id绑定存入一个Map中
7. // 这里computeIfAbsent方法先从集合中通过id获取，如果获取不到则将第二个参数存入集合中返回
8. HystrixCommand.Setter setter = getConfigurations().computeIfAbsent(id, defaultConfiguration);
9. return new HystrixCircuitBreaker(setter);
10. }
11. }

上面创建的是HystrixCircuitBreaker断路器，当执行run方法时:

1. public class HystrixCircuitBreaker implements CircuitBreaker {
2. private HystrixCommand.Setter setter;
3. public HystrixCircuitBreaker(HystrixCommand.Setter setter) {
4. this.setter = setter;
5. }
6. @Override
7. public T run(Supplier toRun, Function fallback) {
8. // 最终执行的就是Hystrix的核心 HystrixCommand对象
9. HystrixCommand command = new HystrixCommand (setter) {
10. @Override
11. protected T run() throws Exception {
12. return toRun.get();
13. }
14. @Override
15. protected T getFallback() {
16. return fallback.apply(getExecutionException());
17. }
18. };
19. return command.execute();
20. }
21. }

原文链接：https://www.toutiao.com/a7036197230167982630/ 。

最后此篇关于Spring Cloud 中断路器 Circuit Breaker 的应用的文章就讲到这里了,如果你想了解更多关于Spring Cloud 中断路器 Circuit Breaker 的应用的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。