Spring Cloud Circuit Breaker 是 Spring Cloud 生态中的一个重要组件，主要用于实现**熔断器模式（Circuit Breaker Pattern）**

Spring Cloud Circuit Breaker 1.0.2 分析

Spring Cloud Circuit Breaker 是 Spring Cloud 生态中的一个重要组件，主要用于实现熔断器模式（Circuit Breaker Pattern），帮助分布式系统在依赖服务出现故障时实现容错，防止故障扩散。1.0.2 版本是该组件的早期稳定版本，以下从核心功能、架构设计、集成实现、使用场景等方面进行详细分析。

一、核心功能与设计目标

1. 熔断器模式的核心实现

熔断器模式是分布式系统容错的经典模式，其核心思想是通过“状态机”管理对依赖服务的调用：

• 关闭状态（Closed）：正常调用依赖服务，同时记录失败率；当失败率达到阈值时，切换到“打开状态”。
• 打开状态（Open）：直接拒绝调用，避免对故障服务的无效请求，同时启动超时计时器；超时后切换到“半开状态”。
• 半开状态（Half-Open）：允许部分请求尝试调用依赖服务；若成功则切换到“关闭状态”，若失败则回到“打开状态”。

Spring Cloud Circuit Breaker 1.0.2 封装了这一逻辑，让开发者无需手动实现状态切换和失败统计。

2. 设计目标

• 抽象与适配：定义统一的熔断器接口，适配多种底层熔断器实现（如 Resilience4j、Hystrix 等）。
• 简化配置：通过 Spring Boot 自动配置，减少开发者的手动配置工作。
• 与 Spring 生态集成：无缝集成 Spring Cloud 其他组件（如 Spring Cloud Gateway、Feign 等）。

二、架构与核心组件

1. 架构分层

Spring Cloud Circuit Breaker 采用分层设计，主要分为：

• API 层：定义统一的熔断器接口（如 CircuitBreaker、CircuitBreakerFactory），开发者面向此接口编程。
• 适配层：针对不同的底层熔断器（如 Resilience4j），实现 API 层的接口，将统一接口转换为具体熔断器的操作。
• 自动配置层：通过 Spring Boot 的 @Configuration 类，根据依赖自动配置适配层的实现，简化集成。

2. 核心接口与类

• CircuitBreaker：熔断器的核心接口，定义了执行目标方法的逻辑（如 run() 方法），内部封装了状态判断、失败统计等逻辑。

  public interface CircuitBreaker {
      <T> T run(Supplier<T> supplier, Function<Throwable, T> fallback);
  }
  

• CircuitBreakerFactory：用于创建 CircuitBreaker 实例的工厂接口，不同的底层实现会提供对应的工厂类（如 Resilience4jCircuitBreakerFactory）。
• CircuitBreakerRegistry：用于管理熔断器实例的注册中心，可通过名称获取已创建的熔断器。

三、底层熔断器适配

Spring Cloud Circuit Breaker 1.0.2 支持多种底层熔断器，开发者可根据需求选择：

以 Resilience4j 为例的适配逻辑

Resilience4j 是 1.0.2 版本推荐的底层实现，其适配逻辑如下：

1. 通过 Resilience4jCircuitBreakerFactory 创建 CircuitBreaker 实例，内部关联 Resilience4j 的 io.github.resilience4j.circuitbreaker.CircuitBreaker。
2. 将 Spring Cloud Circuit Breaker 的配置（如失败率阈值、超时时间）转换为 Resilience4j 的配置。
3. 当调用 run() 方法时，通过 Resilience4j 的熔断器执行目标方法，并处理 fallback 逻辑。

四、使用方式

1. 依赖配置

以 Resilience4j 为例，在 pom.xml 中添加依赖：

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

2. 基本使用示例

import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
import org.springframework.stereotype.Service;

@Service
public class DemoService {
    private final CircuitBreaker circuitBreaker;

    // 注入熔断器工厂，创建熔断器实例
    public DemoService(CircuitBreakerFactory<?, ?> factory) {
        this.circuitBreaker = factory.create("demoCircuitBreaker");
    }

    public String callRemoteService() {
        // 使用熔断器执行远程调用，定义 fallback 逻辑
        return circuitBreaker.run(
            () -> {
                // 调用远程服务的逻辑
                return remoteService.invoke();
            },
            throwable -> {
                // 失败时的 fallback 处理
                return "fallback response";
            }
        );
    }
}

3. 配置参数

通过 application.yml 可配置熔断器的核心参数（以 Resilience4j 为例）：

resilience4j:
  circuitbreaker:
    instances:
      demoCircuitBreaker:
        failure-rate-threshold: 50  # 失败率阈值（达到后打开熔断器）
        wait-duration-in-open-state: 10000  # 打开状态持续时间（毫秒）
        permitted-number-of-calls-in-half-open-state: 3  # 半开状态允许的调用次数
        sliding-window-size: 10  # 统计失败率的滑动窗口大小

五、与 Spring Cloud 其他组件集成

1. 与 Feign 集成

Feign 是声明式 HTTP 客户端，可通过配置启用熔断器，当调用失败时执行 fallback 方法：

feign:
  circuitbreaker:
    enabled: true  # 启用熔断器

@FeignClient(name = "remote-service", fallback = RemoteServiceFallback.class)
public interface RemoteServiceClient {
    @GetMapping("/api/data")
    String getData();
}

@Component
class RemoteServiceFallback implements RemoteServiceClient {
    @Override
    public String getData() {
        return "fallback data";
    }
}

2. 与 Spring Cloud Gateway 集成

在网关层使用熔断器，防止后端服务故障导致网关阻塞：

spring:
  cloud:
    gateway:
      routes:
        - id: remote-service
          uri: lb://remote-service
          predicates:
            - Path=/api/**filters:
            - name: CircuitBreaker
              args:
                name: remoteServiceCircuitBreaker
                fallbackUri: forward:/fallback  # 失败时的 fallback 路径

六、版本特性与注意事项

1. 1.0.2 版本特性

• 基于 Spring Cloud Hoxton 版本构建，兼容 Spring Boot 2.2.x。
• 新增对 Resilience4j 的优先支持（Hystrix 逐渐被替代）。
• 修复了早期版本中与 Spring Retry 集成的冲突问题。
• 优化了熔断器状态切换的性能。

2. 注意事项

• Hystrix 兼容性：由于 Hystrix 已停止更新，1.0.2 版本虽支持但不推荐使用，建议优先选择 Resilience4j。
• 配置冲突：若同时引入多个底层熔断器依赖，需通过 spring.cloud.circuitbreaker.factory-id 指定默认实现。
• 线程模型：不同底层熔断器的线程模型不同（如 Resilience4j 可使用主线程，Hystrix 默认使用线程池），需根据业务场景选择。

七、总结

Spring Cloud Circuit Breaker 1.0.2 作为 Spring Cloud 生态中容错机制的核心组件，通过抽象统一的接口简化了熔断器的使用，并适配多种底层实现，帮助开发者快速构建可靠的分布式系统。其与 Feign、Gateway 等组件的无缝集成，进一步降低了分布式系统的容错实现成本。

对于开发者而言，建议优先选择 Resilience4j 作为底层熔断器，结合 1.0.2 版本的自动配置能力，可快速实现服务的熔断、降级功能，提升系统的稳定性。
Spring Cloud Circuit Breaker 1.0.2
Spring Cloud Circuit breaker provides an abstraction across different circuit breaker implementations. It provides a consistent API to use in your applications allowing you the developer to choose the circuit breaker implementation that best fits your needs for your app.
Supported Implementations

Netfix Hystrix

Resilience4J

Sentinel

Spring Retry

Core Concepts

To create a circuit breaker in your code you can use the CircuitBreakerFactory API. When you include a Spring Cloud Circuit Breaker starter on your classpath a bean implementing this API will automatically be created for you. A very simple example of using this API is given below

@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");
}

}

The CircuitBreakerFactory.create API will create an instance of a class called CircuitBreaker. The run method takes a Supplier and a Function. The Supplier is the code that you are going to wrap in a circuit breaker. The Function is the fallback that will be executed if the circuit breaker is tripped. The function will be passed the Throwable that caused the fallback to be triggered. You can optionally exclude the fallback if you do not want to provide one.
Circuit Breakers In Reactive Code

If Project Reactor is on the class path then you can also use ReactiveCircuitBreakerFactory for your reactive code.

@Service
public static class DemoControllerService {
private ReactiveCircuitBreakerFactory cbFactory;
private WebClient webClient;

public DemoControllerService(WebClient webClient, ReactiveCircuitBreakerFactory cbFactory) {
	this.webClient = webClient;
	this.cbFactory = cbFactory;
}

public Mono<String> slow() {
	return webClient.get().uri("/slow").retrieve().bodyToMono(String.class).transform(
	it -> cbFactory.create("slow").run(it, throwable -> return Mono.just("fallback")));
}

}

The ReactiveCircuitBreakerFactory.create API will create an instance of a class called ReactiveCircuitBreaker. The run method takes with a Mono or Flux and wraps it in a circuit breaker. You can optionally profile a fallback Function which will be called if the circuit breaker is tripped and will be passed the Throwable that caused the failure.
Spring Boot Config

The following starters are available with the Spring Cloud BOM

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-reator-resilience4j

Spring Retry - org.springframework.cloud:spring-cloud-starter-circuitbreaker-spring-retry

Sentinal - org.springframework.cloud:spring-cloud-starter-circuitbreaker-sentinal