SpringCloud CircuitBreaker断路器应用详解

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

环境: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,如:CircuitBreakerCircuitBreakerFactory这些接口(抽象类)的定义都在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创建方法参数中有几个非常重要的核心类:

  1. CircuitBreakerRegistry

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

  1. TimeLimiterRegistry

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

  1. 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的实现原理及配置实现

责任编辑:武晓燕 来源: 实战案例锦集
相关推荐

2021-12-09 08:57:46

Spring ClouCircuit Bre断路器

2021-12-15 08:15:26

Spring Circuit BreSpring Clou

2022-10-08 11:39:56

断路器Golang项目

2022-09-15 15:25:47

spring-微服务

2020-09-15 08:38:13

Sentinel拦截Spring

2023-11-06 08:25:33

项目远程接口

2019-10-15 08:41:37

SpringCloud框架服务器

2023-11-09 18:01:46

JavaSpring容器化

2017-03-13 08:58:46

Spring Clou概览架构

2017-06-25 13:33:25

Spring Clou微服务架构

2023-02-07 07:43:27

微服务应用框架

2022-05-29 21:38:11

限流熔断流量

2013-05-23 13:31:38

路由器路由器故障路由器故障排除
点赞
收藏

51CTO技术栈公众号