1. 使用文档

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

1.1. 配置 Resilience4J 断路器

1.1.1. Starters

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

  • org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j- 非反应性应用spring-doc.cadn.net.cn

  • org.springframework.cloud:spring-cloud-starter-circuitbreaker-reactor-resilience4j- 响应式应用程序spring-doc.cadn.net.cn

1.1.2. 自动配置

您可以通过设置spring.cloud.circuitbreaker.resilience4j.enabled自false.spring-doc.cadn.net.cn

1.1.3. 默认配置

要为所有断路器提供默认配置，请创建一个Customizebean 的 bean 传递一个Resilience4JCircuitBreakerFactory或ReactiveResilience4JCircuitBreakerFactory. 这configureDefaultmethod 可用于提供默认配置。spring-doc.cadn.net.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. 特定断路器配置

与提供默认配置类似，您可以创建一个Customizebean 中，它会传递一个Resilience4JCircuitBreakerFactory或ReactiveResilience4JCircuitBreakerFactory.spring-doc.cadn.net.cn

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

除了配置创建的断路器外，您还可以在创建断路器之后、将其返回给调用方之前自定义该断路器。 为此，您可以使用addCircuitBreakerCustomizer方法。 这对于向 Resilience4J 断路器添加事件处理程序非常有用。spring-doc.cadn.net.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. 断路器属性配置

您可以配置CircuitBreaker和TimeLimiter实例。 Property configuration 的优先级高于 JavaCustomizer配置。spring-doc.cadn.net.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.cadn.net.cn

1.1.6. 隔板模式支持

如果resilience4j-bulkhead在 Classpath 上，Spring Cloud CircuitBreaker 将使用Resilience4j Bulkhead包装所有方法。 您可以通过设置spring.cloud.circuitbreaker.bulkhead.resilience4j.enabled自false.spring-doc.cadn.net.cn

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

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

这Customizer<Resilience4jBulkheadProvider>可用于提供默认的Bulkhead和ThreadPoolBulkhead配置。spring-doc.cadn.net.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' 配置类似，您可以创建一个Customize豆这个 将传递一个Resilience4jBulkheadProvider.spring-doc.cadn.net.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 之后对其进行自定义 已创建，但在它们返回给调用方之前。为此，您可以使用addBulkheadCustomizer和addThreadPoolBulkheadCustomizer方法。spring-doc.cadn.net.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 的优先级高于 JavaCustomizer配置。spring-doc.cadn.net.cn

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

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

1.1.9. 收集度量

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

您不必包含micrometer-core直接引入spring-boot-starter-actuator

1.2. 配置 Spring Retry 断路器

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

1.2.1. 默认配置

要为所有断路器提供默认配置，请创建一个Customizebean 的 bean 传递一个SpringRetryCircuitBreakerFactory. 这configureDefaultmethod 可用于提供默认配置。spring-doc.cadn.net.cn

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

1.2.2. 特定断路器配置

与提供默认配置类似，您可以创建一个Customizebean 中，它会传递一个SpringRetryCircuitBreakerFactory.spring-doc.cadn.net.cn

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

除了配置创建的断路器外，您还可以在创建断路器之后、将其返回给调用方之前自定义该断路器。 为此，您可以使用addRetryTemplateCustomizers方法。 这对于将事件处理程序添加到RetryTemplate.spring-doc.cadn.net.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) {

        }
    }));
}