SpringCloud CircuitBreaker断路器应用详解

Springboot实战案例锦集 2023-03-28 原文

环境：Springboot2.6.14 + Spring Cloud2021.0.5

概述

Spring Cloud Circuit breaker提供了一个跨不同断路器实现的抽象。它为你的应用程序提供了一致的API，让你(开发人员)选择最适合你应用程序需求的断路器实现。

Spring Cloud支持以下断路器实现:

Resilience4J
Sentinel
Spring Retry

核心概念

要在代码中创建断路器，可以使用CircuitBreakerFactory API。当你在classpath中包含SpringCloud CircuitBreaker启动器时，会自动为你创建一个实现了这个API的bean。下面的例子展示了如何使用这个API:

@Service
public static class DemoControllerService {
  private RestTemplate rest;
  private CircuitBreakerFactory cbFactory;


  public DemoControllerService(RestTemplate rest, CircuitBreakerFactory cbFactory) {
    this.rest = rest;
    this.cbFactory = cbFactory;
  }


  public String slow() {
    return cbFactory.create("slow").run(() -> rest.getForObject("/slow", String.class), throwable -> "fallback");
  }


}

以上是断路器的基本使用方法。CircuitBreakerFactory.create API创建一个名为CircuitBreaker的类实例。run方法接受一个Supplier和一个Function作为参数。Supplier是要封装在断路器中的代码。该函数是在断路器跳闸时运行的备用机制也就是会调用run方法的第二个参数Function。

实现原理

自动配置

在上面我们所看到的API，如：CircuitBreaker，CircuitBreakerFactory这些接口(抽象类)的定义都在Spring Cloud Commons包中定义，而具体的实现我们还需要自己根据情况引入。如Resilience4J或者Sentinel，本篇内容使用Resilience4J。

首先，引入Ressilience4J自动配置

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

引入该依赖后自动配置CircuitBreakerFactory的实现

// 可以通过spring.cloud.circuitbreaker.resilience4j.enabled控制是否启用，默认开启
@EnableConfigurationProperties(Resilience4JConfigurationProperties.class)
@ConditionalOnProperty(name = { "spring.cloud.circuitbreaker.resilience4j.enabled",
    "spring.cloud.circuitbreaker.resilience4j.blocking.enabled" }, matchIfMissing = true)
public class Resilience4JAutoConfiguration {
  @Autowired(required = false)
  private List<Customizer<Resilience4JCircuitBreakerFactory>> customizers = new ArrayList<>();


  @Bean
  @ConditionalOnMissingBean(CircuitBreakerFactory.class)
  public Resilience4JCircuitBreakerFactory resilience4jCircuitBreakerFactory(
    CircuitBreakerRegistry circuitBreakerRegistry, TimeLimiterRegistry timeLimiterRegistry,
    @Autowired(required = false) Resilience4jBulkheadProvider bulkheadProvider,
    Resilience4JConfigurationProperties resilience4JConfigurationProperties) {
    Resilience4JCircuitBreakerFactory factory = new Resilience4JCircuitBreakerFactory(circuitBreakerRegistry,
      timeLimiterRegistry, bulkheadProvider, resilience4JConfigurationProperties);
    customizers.forEach(customizer -> customizer.customize(factory));
    return factory;
  }  
}

有了上面的工厂类Resilience4JCircuitBreakerFactory后我们就可以通过该工厂进行实际的开发了。

在上面的Bean创建方法参数中有几个非常重要的核心类：

CircuitBreakerRegistry

该类用来配置注册创建CircuitBreaker实例。

TimeLimiterRegistry

该类用来注册配置每一个实例（CircuitBreaker）的时间限制。

Resilience4jBulkheadProvider

该类主要是提供了隔离机制，其内通过BulkheadRegistry及
ThreadPoolBulkheadRegistry注册配置每一个实例的隔离机制及线程池隔离配置。

核心类Resilience4JCircuitBreakerFactory

在需要进行熔断降级操作都需用通过该工厂进行创建CircuitBreaker实例

public class Resilience4JCircuitBreakerFactory {
  private CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
  private TimeLimiterRegistry timeLimiterRegistry = TimeLimiterRegistry.ofDefaults();
  private ExecutorService executorService = Executors.newCachedThreadPool();
  private Function<String, Resilience4JConfigBuilder.Resilience4JCircuitBreakerConfiguration> defaultConfiguration;


  public Resilience4JCircuitBreakerFactory(CircuitBreakerRegistry circuitBreakerRegistry,
    TimeLimiterRegistry timeLimiterRegistry, Resilience4jBulkheadProvider bulkheadProvider,
    Resilience4JConfigurationProperties resilience4JConfigurationProperties) {
    this.circuitBreakerRegistry = circuitBreakerRegistry;
    this.timeLimiterRegistry = timeLimiterRegistry;
    this.bulkheadProvider = bulkheadProvider;
    // 获取默认的配置（当没有为具体的id实例创建配置时，使用该默认配置）
    this.defaultConfiguration = id -> new Resilience4JConfigBuilder(id)
      .circuitBreakerConfig(this.circuitBreakerRegistry.getDefaultConfig())
      .timeLimiterConfig(this.timeLimiterRegistry.getDefaultConfig()).build();
    this.resilience4JConfigurationProperties = resilience4JConfigurationProperties;
  }
}

创建CircuitBreaker实例

public Resilience4JCircuitBreaker create(String id) {
  return create(id, id, this.executorService);
}
private Resilience4JCircuitBreaker create(String id, String groupName,
  ExecutorService circuitBreakerExecutorService) {
  // 根据实例id获取对应的配置，如果不存在则使用默认的配置
  // 初始是没有对应id的配置
  Resilience4JConfigBuilder.Resilience4JCircuitBreakerConfiguration config = getConfigurations()
    .computeIfAbsent(id, defaultConfiguration);
  // spring.cloud.circuitbreaker.resilience4j.disableThreadPool 默认false
  if (resilience4JConfigurationProperties.isDisableThreadPool()) {
    return new Resilience4JCircuitBreaker(id, groupName, config.getCircuitBreakerConfig(),
      config.getTimeLimiterConfig(), circuitBreakerRegistry, timeLimiterRegistry,
      Optional.ofNullable(circuitBreakerCustomizers.get(id)), bulkheadProvider);
  } else {
    // 创建CircuitBreaker实例，这里的config.getCircuitBreakerConfig和config.getTimeLimiterConfig
    // 两个方法返回的默认的配置（首次）
    return new Resilience4JCircuitBreaker(id, groupName, config.getCircuitBreakerConfig(),
      config.getTimeLimiterConfig(), circuitBreakerRegistry, timeLimiterRegistry,
      circuitBreakerExecutorService, Optional.ofNullable(circuitBreakerCustomizers.get(id)),bulkheadProvider);
  }
}

Resilience4JCircuitBreaker实例

public class Resilience4JCircuitBreaker implements CircuitBreaker {
  public Resilience4JCircuitBreaker(String id, String groupName,
      io.github.resilience4j.circuitbreaker.CircuitBreakerConfig circuitBreakerConfig,
      TimeLimiterConfig timeLimiterConfig, CircuitBreakerRegistry circuitBreakerRegistry,
      TimeLimiterRegistry timeLimiterRegistry, ExecutorService executorService,
      Optional<Customizer<io.github.resilience4j.circuitbreaker.CircuitBreaker>> circuitBreakerCustomizer,
      Resilience4jBulkheadProvider bulkheadProvider) {
    this.id = id;
    this.groupName = groupName;
    this.circuitBreakerConfig = circuitBreakerConfig;
    this.registry = circuitBreakerRegistry;
    this.timeLimiterRegistry = timeLimiterRegistry;
    this.timeLimiterConfig = timeLimiterConfig;
    this.executorService = executorService;
    // ...
  }
  public <T> T run(Supplier<T> toRun, Function<Throwable, T> fallback) {
    // ...
    // 下面的CircuitBreaker和TimeLimiter都会先从Registry中获取，不存在则使用默认的
    // 从CircuitBreakerRegistry获取对应Id实例配置，如果不存在则返回的就是当前circuitBreakerConfig
    io.github.resilience4j.circuitbreaker.CircuitBreaker defaultCircuitBreaker = registry.circuitBreaker(this.id,
        this.circuitBreakerConfig, tags);
    // 如果对应Id实例配置不存在则应用默认的timeLimiterConfig配置
    TimeLimiter timeLimiter = timeLimiterRegistry.timeLimiter(id, timeLimiterConfig, tags);
    // ...
  }
}

CircuitBreakerRegistry注册器

该注册器将配置文件中配置的实例配置进行注册并提供默认的配置

@Import({CircuitBreakerConfigurationOnMissingBean.class, FallbackConfigurationOnMissingBean.class})
public class CircuitBreakerAutoConfiguration {}

CircuitBreakerConfigurationOnMissingBean该类注册CircuitBreakerRegistry

@Configuration
public class CircuitBreakerConfigurationOnMissingBean extends AbstractCircuitBreakerConfigurationOnMissingBean {


  public CircuitBreakerConfigurationOnMissingBean(CircuitBreakerConfigurationProperties circuitBreakerProperties) {
    super(circuitBreakerProperties);
  }
}

属性配置

// 相关配置都在该属性配置中
@ConfigurationProperties(prefix = "resilience4j.circuitbreaker")
public class CircuitBreakerProperties extends CircuitBreakerConfigurationProperties {}

AbstractCircuitBreakerConfigurationOnMissingBean

@Configuration
@Import({FallbackConfigurationOnMissingBean.class, SpelResolverConfigurationOnMissingBean.class})
public abstract class AbstractCircuitBreakerConfigurationOnMissingBean {
  protected final CircuitBreakerConfiguration circuitBreakerConfiguration;
  protected final CircuitBreakerConfigurationProperties circuitBreakerProperties;
  public AbstractCircuitBreakerConfigurationOnMissingBean(CircuitBreakerConfigurationProperties circuitBreakerProperties) {
    this.circuitBreakerProperties = circuitBreakerProperties;
    this.circuitBreakerConfiguration = new CircuitBreakerConfiguration(circuitBreakerProperties);
  }
  @Bean
  @ConditionalOnMissingBean
  public CircuitBreakerRegistry circuitBreakerRegistry(
      EventConsumerRegistry<CircuitBreakerEvent> eventConsumerRegistry,
      RegistryEventConsumer<CircuitBreaker> circuitBreakerRegistryEventConsumer,
      @Qualifier("compositeCircuitBreakerCustomizer") CompositeCustomizer<CircuitBreakerConfigCustomizer> compositeCircuitBreakerCustomizer) {
    // 创建实例
    return circuitBreakerConfiguration
      .circuitBreakerRegistry(eventConsumerRegistry, circuitBreakerRegistryEventConsumer,compositeCircuitBreakerCustomizer);
  }
}

CircuitBreakerConfiguration

@Configuration
public class CircuitBreakerConfiguration {
  private final CircuitBreakerConfigurationProperties circuitBreakerProperties;
  public CircuitBreakerConfiguration(CircuitBreakerConfigurationProperties circuitBreakerProperties) {
    this.circuitBreakerProperties = circuitBreakerProperties;
  }
  @Bean
  public CircuitBreakerRegistry circuitBreakerRegistry(
      EventConsumerRegistry<CircuitBreakerEvent> eventConsumerRegistry,
      RegistryEventConsumer<CircuitBreaker> circuitBreakerRegistryEventConsumer,
      @Qualifier("compositeCircuitBreakerCustomizer") CompositeCustomizer<CircuitBreakerConfigCustomizer> compositeCircuitBreakerCustomizer) {
    // 将resilience4j.circuitbreaker.configs所有配置进行注册
    CircuitBreakerRegistry circuitBreakerRegistry = createCircuitBreakerRegistry(
    circuitBreakerProperties, circuitBreakerRegistryEventConsumer,
    compositeCircuitBreakerCustomizer);
    //...
    // 将resilience4j.circuitbreaker.instances所有配置进行注册
    initCircuitBreakerRegistry(circuitBreakerRegistry, compositeCircuitBreakerCustomizer);
    return circuitBreakerRegistry;
  }
}

上面的configs和instances所有的配置都会注册到AbstractRegistry.entryMap中。

获取实例Id配置

io.github.resilience4j.circuitbreaker.CircuitBreaker defaultCircuitBreaker = registry.circuitBreaker(this.id,this.circuitBreakerConfig, tags);
// InMemoryCircuitBreakerRegistry
public CircuitBreaker circuitBreaker(String name, CircuitBreakerConfig config,io.vavr.collection.Map<String, String> tags) {
  return computeIfAbsent(name, () -> CircuitBreaker.of(name, Objects.requireNonNull(config, CONFIG_MUST_NOT_BE_NULL), getAllTags(tags)));
}
// AbstractRegistry
protected E computeIfAbsent(String name, Supplier<E> supplier) {
  // 从map获取
  return entryMap.computeIfAbsent(Objects.requireNonNull(name, NAME_MUST_NOT_BE_NULL), k -> {
    E entry = supplier.get();
    eventProcessor.processEvent(new EntryAddedEvent<>(entry));
    return entry;
  });
}

TimeLimiterRegistry注册器

该配置与CircuitBreakerRegistry的配置类似，这里不赘述

以上就是Resilience4J的实现原理

Resilience4J配置

resilience4j:
  circuitbreaker:
    #configs:
    #  default:
    #    minimumNumberOfCalls: 5 #默认配置
    instances:
      #在Feign中使用的命名
      DemoFeignformat:
        minimumNumberOfCalls: 5
      lkk:
        minimumNumberOfCalls: 2
  timelimiter:
    configs:
      #为任何调用提供默认的配置
      default:
        timeoutDuration: 1s
    instances:
      DemoFeignformat:
        timeoutDuration: 1s
      DemoFeigndate3:
        timeoutDuration: 5s       
      lkk:
        timeoutDuration: 1s

在上面Feign的命名规则如下：

如果开启了如下配置：

feign:
  circuitbreaker:
    enabled: true
    alphanumericIds:
      enabled: true

public class FeignClientFactoryBean {
  <T> T getTarget() {
    Feign.Builder builder = feign(context); 
  }
}
public final class FeignCircuitBreaker {
  public static final class Builder extends Feign.Builder {
  public Feign build(final FallbackFactory<?> nullableFallbackFactory) {
    // FeignCircuitBreakerInvocationHandler执行调用
    super.invocationHandlerFactory((target, dispatch) -> new FeignCircuitBreakerInvocationHandler(circuitBreakerFactory, 
      feignClientName, target, dispatch, nullableFallbackFactory,
      circuitBreakerGroupEnabled, circuitBreakerNameResolver));
      return super.build();
    }
  }
}

FeignCircuitBreakerInvocationHandler

class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
  private final CircuitBreakerNameResolver circuitBreakerNameResolver;
  public Object invoke() {
    String circuitName = circuitBreakerNameResolver.resolveCircuitBreakerName(feignClientName, target, method);
    CircuitBreaker circuitBreaker = circuitBreakerGroupEnabled ? factory.create(circuitName, feignClientName) : factory.create(circuitName);
  }
}
static class AlphanumericCircuitBreakerNameResolver extends DefaultCircuitBreakerNameResolver {


  @Override
  public String resolveCircuitBreakerName(String feignClientName, Target<?> target, Method method) {
    return super.resolveCircuitBreakerName(feignClientName, target, method).replaceAll("[^a-zA-Z0-9]", "");
  }
}
static class DefaultCircuitBreakerNameResolver implements CircuitBreakerNameResolver {


  @Override
  public String resolveCircuitBreakerName(String feignClientName, Target<?> target, Method method) {
    return Feign.configKey(target.type(), method);
  }
}
public abstract class Feign {
  // 开启了Alphanumeric会将特殊字符全部删除
  public static String configKey(Class targetType, Method method) {
    StringBuilder builder = new StringBuilder();
    builder.append(targetType.getSimpleName());
    builder.append('#').append(method.getName()).append('(');
    for (Type param : method.getGenericParameterTypes()) {
      param = Types.resolve(targetType, targetType, param);
      builder.append(Types.getRawType(param).getSimpleName()).append(',');
    }
    if (method.getParameterTypes().length > 0) {
      builder.deleteCharAt(builder.length() - 1);
    }
    return builder.append(')').toString();
  }
}

以上就是基于Resilience4J的实现原理及配置实现

断路 CircuitBreaker span style color 开发前端 $断路器应用 API

有关SpringCloud CircuitBreaker断路器应用详解的更多相关文章

ruby - 将差异补丁应用于字符串/文件 - 2
对于具有离线功能的智能手机应用程序，我正在为Xml文件创建单向文本同步。我希望我的服务器将增量/差异(例如GNU差异补丁)发送到目标设备。这是计划:Time=0Server:hasversion_1ofXmlfile(~800kiB)Client:hasversion_1ofXmlfile(~800kiB)Time=1Server:hasversion_1andversion_2ofXmlfile(each~800kiB)computesdeltaoftheseversions(=patch)(~10kiB)sendspatchtoClient(~10kiBtransferred)Cl
ruby-on-rails - Rails 应用程序之间的通信 - 2
我构建了两个需要相互通信和发送文件的Rails应用程序。例如，一个Rails应用程序会发送请求以查看其他应用程序数据库中的表。然后另一个应用程序将呈现该表的json并将其发回。我还希望一个应用程序将存储在其公共(public)目录中的文本文件发送到另一个应用程序的公共(public)目录。我从来没有做过这样的事情，所以我什至不知道从哪里开始。任何帮助，将不胜感激。谢谢! 最佳答案无论Rails是什么，几乎所有Web应用程序都有您的要求，大多数现代Web应用程序都需要相互通信。但是有一个小小的理解需要你坚持下去，网站不应直接访问彼此
ruby - 无法运行 Rails 2.x 应用程序 - 2
我尝试运行2.x应用程序。我使用rvm并为此应用程序设置其他版本的ruby:$rvmuseree-1.8.7-head我尝试运行服务器，然后出现很多错误:$script/serverNOTE:Gem.source_indexisdeprecated,useSpecification.Itwillberemovedonorafter2011-11-01.Gem.source_indexcalledfrom/Users/serg/rails_projects_terminal/work_proj/spohelp/config/../vendor/rails/railties/lib/r
ruby-on-rails - Rails 应用程序中的 Rails : How are you using application_controller. rb 是新手吗？ - 2
刚入门rails，开始慢慢理解。有人可以解释或给我一些关于在application_controller中编码的好处或时间和原因的想法吗？有哪些用例。您如何为Rails应用程序使用应用程序Controller？我不想在那里放太多代码，因为据我了解，每个请求都会调用此Controller。这是真的？最佳答案 ApplicationController实际上是您应用程序中的每个其他Controller都将从中继承的类(尽管这不是强制性的)。我同意不要用太多代码弄乱它并保持干净整洁的态度，尽管在某些情况下ApplicationContr
ruby-on-rails - 如何在我的 Rails 应用程序 View 中打印 ruby 变量的内容？ - 2
我是一个Rails初学者，但我想从我的RailsView(html.haml文件)中查看Ruby变量的内容。我试图在ruby中打印出变量(认为它会在终端中出现)，但没有得到任何结果。有什么建议吗？我知道Rails调试器，但更喜欢使用inspect来打印我的变量。最佳答案您可以在View中使用puts方法将信息输出到服务器控制台。您应该能够在View中的任何位置使用Haml执行以下操作:-puts@my_variable.inspect 关于ruby-on-rails-如何在我的R
ruby-on-rails - 如何在 Gem 中获取 Rails 应用程序的根目录 - 2
是否可以在应用程序中包含的gem代码中知道应用程序的Rails文件系统根目录？这是gem来源的示例:moduleMyGemdefself.included(base)putsRails.root#returnnilendendActionController::Base.send:include,MyGem谢谢，抱歉我的英语不好最佳答案我发现解决类似问题的解决方案是使用railtie初始化程序包含我的模块。所以，在你的/lib/mygem/railtie.rbmoduleMyGemclassRailtie使用此代码，您的模块将在
世界前沿3D开发引擎HOOPS全面讲解——集3D数据读取、3D图形渲染、3D数据发布于一体的全新3D应用开发工具 - 2
无论您是想搭建桌面端、WEB端或者移动端APP应用，HOOPSPlatform组件都可以为您提供弹性的3D集成架构，同时，由工业领域3D技术专家组成的HOOPS技术团队也能为您提供技术支持服务。如果您的客户期望有一种在多个平台（桌面/WEB/APP，而且某些客户端是“瘦”客户端）快速、方便地将数据接入到3D应用系统的解决方案，并且当访问数据时，在各个平台上的性能和用户体验保持一致，HOOPSPlatform将帮助您完成。利用HOOPSPlatform，您可以开发在任何环境下的3D基础应用架构。HOOPSPlatform可以帮您打造3D创新型产品，HOOPSSDK包含的技术有：快速且准确的CAD
叮咚买菜基于 Apache Doris 统一 OLAP 引擎的应用实践 - 2
导读：随着叮咚买菜业务的发展，不同的业务场景对数据分析提出了不同的需求，他们希望引入一款实时OLAP数据库，构建一个灵活的多维实时查询和分析的平台，统一数据的接入和查询方案，解决各业务线对数据高效实时查询和精细化运营的需求。经过调研选型，最终引入ApacheDoris作为最终的OLAP分析引擎，Doris作为核心的OLAP引擎支持复杂地分析操作、提供多维的数据视图，在叮咚买菜数十个业务场景中广泛应用。作者｜叮咚买菜资深数据工程师韩青叮咚买菜创立于2017年5月，是一家专注美好食物的创业公司。叮咚买菜专注吃的事业，为满足更多人“想吃什么”而努力，通过美好食材的供应、美好滋味的开发以及美食品牌的孵
【鸿蒙应用开发系列】- 获取系统设备信息以及版本API兼容调用方式 - 2
在应用开发中，有时候我们需要获取系统的设备信息，用于数据上报和行为分析。那在鸿蒙系统中，我们应该怎么去获取设备的系统信息呢，比如说获取手机的系统版本号、手机的制造商、手机型号等数据。1、获取方式这里分为两种情况，一种是设备信息的获取，一种是系统信息的获取。1.1、获取设备信息获取设备信息，鸿蒙的SDK包为我们提供了DeviceInfo类，通过该类的一些静态方法，可以获取设备信息，DeviceInfo类的包路径为：ohos.system.DeviceInfo.具体的方法如下：ModifierandTypeMethodDescriptionstatic StringgetAbiList()Obt
ruby-on-rails - 从应用程序中自定义文件夹内的命名空间自动加载 - 2
我们目前正在为ROR3.2开发自定义cms引擎。在这个过程中，我们希望成为我们的rails应用程序中的一等公民的几个类类型起源，这意味着它们应该驻留在应用程序的app文件夹下，它是插件。目前我们有以下类型:数据源数据类型查看我在app文件夹下创建了多个目录来保存这些:应用/数据源应用/数据类型应用/View更多类型将随之而来，我有点担心应用程序文件夹被这么多目录污染。因此，我想将它们移动到一个子目录/模块中，该子目录/模块包含cms定义的所有类型。所有类都应位于MyCms命名空间内，目录布局应如下所示:应用程序/my_cms/data_source应用程序/my_cms/data_ty

SpringCloud CircuitBreaker断路器应用详解

概述

核心概念

实现原理

Resilience4J配置

有关SpringCloud CircuitBreaker断路器应用详解的更多相关文章

随机推荐