1. 使用文档 (1. Usage Documentation) _ Spring Cloud Circuit Breaker2.0.4-SNAPSHOT中文文档(官方文档中文翻译)|Spring 教程 —

1. 使用文档

Spring Cloud CircuitBreaker 项目包含 Resilience4J 和 Spring Retry 的实现。在 Spring Cloud CircuitBreaker 中实现的 API 位于 Spring Cloud Commons 中。使用文档这些 API 位于 Spring Cloud Commons 文档中。spring-doc.cn

1.1. 配置 Resilience4J 断路器

1.1.1. Starters

Resilience4J 实施有两个Starters，一个用于响应式应用程序，一个用于非响应式应用程序。spring-doc.cn

org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j- 非反应性应用spring-doc.cn
org.springframework.cloud:spring-cloud-starter-circuitbreaker-reactor-resilience4j- 响应式应用程序spring-doc.cn

1.1.2. 自动配置

您可以通过设置为来禁用 Resilience4J 自动配置。spring.cloud.circuitbreaker.resilience4j.enabledfalsespring-doc.cn

1.1.3. 默认配置

要为所有断路器提供默认配置，请创建一个传递或的 bean。该方法可用于提供默认配置。CustomizeResilience4JCircuitBreakerFactoryReactiveResilience4JCircuitBreakerFactoryconfigureDefaultspring-doc.cn

@Bean
public Customizer<Resilience4JCircuitBreakerFactory> defaultCustomizer() {
    return factory -> factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
            .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(4)).build())
            .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
            .build());
}

反应式示例

@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> defaultCustomizer() {
    return factory -> factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
            .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
            .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(4)).build()).build());
}

1.1.4. 特定断路器配置

与提供默认配置类似，您可以创建一个 bean，该 bean 将传递或。CustomizeResilience4JCircuitBreakerFactoryReactiveResilience4JCircuitBreakerFactoryspring-doc.cn

@Bean
public Customizer<Resilience4JCircuitBreakerFactory> slowCustomizer() {
    return factory -> factory.configure(builder -> builder.circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
            .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(2)).build()), "slow");
}

除了配置创建的断路器外，您还可以在创建断路器之后、将其返回给调用方之前自定义该断路器。为此，您可以使用该方法。这对于向 Resilience4J 断路器添加事件处理程序非常有用。addCircuitBreakerCustomizerspring-doc.cn

@Bean
public Customizer<Resilience4JCircuitBreakerFactory> slowCustomizer() {
    return factory -> factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
    .onError(normalFluxErrorConsumer).onSuccess(normalFluxSuccessConsumer), "normalflux");
}

反应式示例

@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> slowCustomizer() {
    return factory -> {
        factory.configure(builder -> builder
        .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(2)).build())
        .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults()), "slow", "slowflux");
        factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
            .onError(normalFluxErrorConsumer).onSuccess(normalFluxSuccessConsumer), "normalflux");
     };
}

1.1.5. 断路器属性配置

您可以在应用程序的配置属性文件中配置和 instances。 Property configuration 的优先级高于 Java configuration。CircuitBreakerTimeLimiterCustomizerspring-doc.cn

resilience4j.circuitbreaker:
 instances:
     backendA:
         registerHealthIndicator: true
         slidingWindowSize: 100
     backendB:
         registerHealthIndicator: true
         slidingWindowSize: 10
         permittedNumberOfCallsInHalfOpenState: 3
         slidingWindowType: TIME_BASED
         recordFailurePredicate: io.github.robwin.exception.RecordFailurePredicate

resilience4j.timelimiter:
 instances:
     backendA:
         timeoutDuration: 2s
         cancelRunningFuture: true
     backendB:
         timeoutDuration: 1s
         cancelRunningFuture: false

有关 Resilience4j 属性配置的更多信息，请参阅 Resilience4J Spring Boot 2 配置。spring-doc.cn

如果在 Classpath 上，则 Spring Cloud CircuitBreaker 将使用Resilience4j Bulkhead包装所有方法。您可以通过设置为来禁用 Resilience4j 隔板。resilience4j-bulkheadspring.cloud.circuitbreaker.bulkhead.resilience4j.enabledfalsespring-doc.cn

Spring Cloud CircuitBreaker Resilience4j 提供了两种隔板模式的实现：spring-doc.cn

a 使用信号量SemaphoreBulkheadspring-doc.cn
a 使用有界队列和固定线程池。FixedThreadPoolBulkheadspring-doc.cn

默认情况下，Spring Cloud CircuitBreaker Resilience4j 使用。有关实施的更多信息的 Bulkhead 模式请参阅 Resilience4j Bulkhead。FixedThreadPoolBulkheadspring-doc.cn

这可用于提供 default 和 configuration。Customizer<Resilience4jBulkheadProvider>BulkheadThreadPoolBulkheadspring-doc.cn

@Bean
public Customizer<Resilience4jBulkheadProvider> defaultBulkheadCustomizer() {
    return provider -> provider.configureDefault(id -> new Resilience4jBulkheadConfigurationBuilder()
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(4).build())
        .threadPoolBulkheadConfig(ThreadPoolBulkheadConfig.custom().coreThreadPoolSize(1).maxThreadPoolSize(1).build())
        .build()
);
}

1.1.7. 特定的 Bulkhead 配置

与证明默认的 'Bulkhead' 或 'ThreadPoolBulkhead' 配置类似，你可以创建一个 bean 将传递一个 .CustomizeResilience4jBulkheadProviderspring-doc.cn

@Bean
public Customizer<Resilience4jBulkheadProvider> slowBulkheadProviderCustomizer() {
    return provider -> provider.configure(builder -> builder
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(1).build())
        .threadPoolBulkheadConfig(ThreadPoolBulkheadConfig.ofDefaults()), "slowBulkhead");
}

除了配置创建的 Bulkhead 之外，您还可以在 bulkhead 和线程池 bulkhead 之后对其进行自定义已创建，但在它们返回给调用方之前。为此，您可以使用 and 方法。addBulkheadCustomizeraddThreadPoolBulkheadCustomizerspring-doc.cn

隔板示例

@Bean
public Customizer<Resilience4jBulkheadProvider> customizer() {
    return provider -> provider.addBulkheadCustomizer(bulkhead -> bulkhead.getEventPublisher()
        .onCallRejected(slowRejectedConsumer)
        .onCallFinished(slowFinishedConsumer), "slowBulkhead");
}

Thread Pool Bulkhead 示例

@Bean
public Customizer<Resilience4jBulkheadProvider> slowThreadPoolBulkheadCustomizer() {
    return provider -> provider.addThreadPoolBulkheadCustomizer(threadPoolBulkhead -> threadPoolBulkhead.getEventPublisher()
        .onCallRejected(slowThreadPoolRejectedConsumer)
        .onCallFinished(slowThreadPoolFinishedConsumer), "slowThreadPoolBulkhead");
}

1.1.8. Bulkhead 属性配置

您可以在应用程序的配置属性文件中配置 ThreadPoolBulkhead 和 SemaphoreBulkhead 实例。 Property configuration 的优先级高于 Java configuration。Customizerspring-doc.cn

resilience4j.thread-pool-bulkhead:
    instances:
        backendA:
            maxThreadPoolSize: 1
            coreThreadPoolSize: 1
resilience4j.bulkhead:
    instances:
        backendB:
            maxConcurrentCalls: 10

有关 Resilience4j 属性配置的更多信息，请参阅 Resilience4J Spring Boot 2 配置。spring-doc.cn

1.1.9. 收集度量

Spring Cloud Circuit Breaker Resilience4j 包括自动配置以设置指标收集，只要正确的 dependencies 位于 Classpath 上。要启用指标收集，必须包括、和。有关，请参阅 Resilience4j 文档。org.springframework.boot:spring-boot-starter-actuatorio.github.resilience4j:resilience4j-micrometerspring-doc.cn

您不必直接包含，因为它是由micrometer-corespring-boot-starter-actuator

1.2. 配置 Spring Retry 断路器

Spring Retry 为 Spring 应用程序提供声明式重试支持。该项目的子集包括实现断路器功能的能力。 Spring Retry 通过其CircuitBreakerRetryPolicy和有状态重试的组合来提供断路器实现。使用 Spring Retry 创建的所有断路器都将使用 the 和 DefaultRetryState 创建。这两个类都可以使用进行配置。CircuitBreakerRetryPolicySpringRetryConfigBuilderspring-doc.cn

1.2.1. 默认配置

要为所有断路器提供默认配置，请创建一个 Bean，该 Bean 将 . 该方法可用于提供默认配置。CustomizeSpringRetryCircuitBreakerFactoryconfigureDefaultspring-doc.cn

@Bean
public Customizer<SpringRetryCircuitBreakerFactory> defaultCustomizer() {
    return factory -> factory.configureDefault(id -> new SpringRetryConfigBuilder(id)
        .retryPolicy(new TimeoutRetryPolicy()).build());
}

1.2.2. 特定断路器配置

与提供默认配置类似，您可以创建一个 bean，该 bean 将传递一个 .CustomizeSpringRetryCircuitBreakerFactoryspring-doc.cn

@Bean
public Customizer<SpringRetryCircuitBreakerFactory> slowCustomizer() {
    return factory -> factory.configure(builder -> builder.retryPolicy(new SimpleRetryPolicy(1)).build(), "slow");
}

除了配置创建的断路器外，您还可以在创建断路器之后、将其返回给调用方之前自定义该断路器。为此，您可以使用该方法。这对于将事件处理程序添加到 .addRetryTemplateCustomizersRetryTemplatespring-doc.cn

@Bean
public Customizer<SpringRetryCircuitBreakerFactory> slowCustomizer() {
    return factory -> factory.addRetryTemplateCustomizers(retryTemplate -> retryTemplate.registerListener(new RetryListener() {

        @Override
        public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
            return false;
        }

        @Override
        public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {

        }

        @Override
        public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) {

        }
    }));
}