熔断器（Hystrix，Resilience4j）

熔断器

核心原理​

熔断器通过监控服务调用失败率，在达到阈值时自动切断请求，进入熔断状态（类似电路保险丝）。其核心流程为：
关闭状态（Closed）​​：正常处理请求，统计失败率。
​​打开状态（Open）​​：触发熔断，直接拒绝请求，调用降级逻辑。
​​半开状态（Half-Open）​​：允许少量请求尝试恢复，若成功则关闭熔断。

状态流转

1. 关闭状态（Closed）​​
   ​​行为​​：熔断器关闭，所有请求正常通过。
   ​​触发条件​​：
   初始默认状态。
   从半开状态恢复成功后切换至此状态。
   ​​核心规则​​：
   统计时间窗口内的请求失败率。
   当失败率超过阈值（如 50%）时，熔断器跳转到 ​​打开状态​​。

# Resilience4j 配置（失败率 ≥ 50% 触发熔断）
resilience4j.circuitbreaker:instances:serviceA:failureRateThreshold: 50minimumNumberOfCalls: 5  # 最少需要5次调用才计算失败率slidingWindowSize: 10     # 统计最近10次调用

2. 打开状态（Open）​
   行为​​：熔断器打开，所有请求被快速拒绝，直接触发降级逻辑。
   ​​触发条件​​：
   关闭状态下失败率超过阈值。
   ​​核心规则​​：
   熔断器保持打开状态一段时间（如 10秒）。
   超时后自动进入 ​​半开状态​​。
3. 半开状态（Half-Open）​
   行为​​：允许少量探测请求通过，若成功则恢复服务，否则重新熔断。
   ​​触发条件​​：
   熔断器从打开状态等待指定时间后自动切换。
   ​​核心规则​​：
   允许有限数量的请求（如 3次）试探性调用。
   若成功率达标（如 80%），则关闭熔断器。
   若失败率仍高，则重新进入 ​​打开状态​​。

# Resilience4j 半开状态配置
resilience4j.circuitbreaker:instances:serviceA:permittedNumberOfCallsInHalfOpenState: 3  # 允许3次探测请求failureRateThreshold: 20                  # 半开状态下失败率≥20%则重新熔断waitDurationInOpenState: 10s              # 打开状态持续10秒后进入半开

Hystrix使用

依赖

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-hystrix</artifactId><version>2.2.10.RELEASE</version> <!-- 对应 Spring Cloud Hoxton.SR12 -->
</dependency>

启用 Hystrix​

@SpringBootApplication
@EnableHystrix          // 启用 Hystrix
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

全局默认配置

hystrix:command:default:execution:isolation:strategy: THREAD  # 隔离策略（THREAD 或 SEMAPHORE）thread:timeoutInMilliseconds: 2000  # 超时时间（默认1秒）circuitBreaker:enabled: true                   # 是否启用熔断requestVolumeThreshold: 5       # 触发熔断的最小请求数errorThresholdPercentage: 50    # 失败率阈值（%）sleepWindowInMilliseconds: 10000 # 熔断持续时间（ms）threadpool:default:coreSize: 10       # 线程池核心线程数maxQueueSize: 100  # 最大队列容量（-1表示禁用队列）queueSizeRejectionThreshold: 20  # 队列拒绝阈值

使用示例

基础熔断与降级​

@Service
public class UserService {@HystrixCommand(fallbackMethod = "getUserFallback",commandProperties = {// 自定义熔断规则（覆盖全局配置）@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "3"),@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")})public String getUser(String userId) {if ("error".equals(userId)) {throw new RuntimeException("模拟服务失败");}return "User:" + userId;}// 降级方法（参数必须与原方法一致）public String getUserFallback(String userId) {return "Fallback User:" + userId;}
}

异步调用​

@HystrixCommand(fallbackMethod = "asyncFallback")
public Future<String> asyncGetUser(String userId) {return new AsyncResult<String>() {@Overridepublic String invoke() {return "Async User:" + userId;}};
}public String asyncFallback(String userId) {return "Async Fallback:" + userId;
}

忽略特定异常​

@HystrixCommand(fallbackMethod = "validateFallback",ignoreExceptions = { IllegalArgumentException.class }  # 此异常不触发熔断
)
public String validate(String input) {if (input.isEmpty()) {throw new IllegalArgumentException("输入为空");}return "Valid:" + input;
}

Hystrix+Feign Client 实现熔断

1. 启用 Hystrix 和 Feign​

@SpringBootApplication
@EnableFeignClients    // 启用 Feign Client
@EnableHystrix          // 启用 Hystrix
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

2. 定义 Feign 接口及降级类​

// Feign Client 接口
@FeignClient(name = "user-service",url = "http://localhost:8081",fallback = UserServiceFallback.class  // 指定降级类
)
public interface UserServiceClient {@GetMapping("/users/{userId}")User getUser(@PathVariable String userId);
}// 降级类实现 Feign 接口
@Component
public class UserServiceFallback implements UserServiceClient {@Overridepublic User getUser(String userId) {return new User(userId, "Fallback User");}
}

3. 配置熔断参数 (application.yml)​

feign:hystrix:enabled: true  # 启用 Hystrix 支持（默认 true，可省略）hystrix:command:default:circuitBreaker:requestVolumeThreshold: 5       # 触发熔断的最小请求数errorThresholdPercentage: 50    # 失败率阈值（%）sleepWindowInMilliseconds: 10000 # 熔断持续时间（ms）execution:isolation:thread:timeoutInMilliseconds: 3000  # 超时时间

4. 禁用 Hystrix 对特定 Feign Client​

@FeignClient(name = "order-service",url = "http://localhost:8082",configuration = FeignDisableHystrixConfig.class
)
public interface OrderServiceClient { ... }// 自定义配置类
public class FeignDisableHystrixConfig {@Beanpublic Feign.Builder feignBuilder() {return Feign.builder();  // 不使用 Hystrix}
}

注意

1. Hystrix 熔断器在 ​​打开状态（Open）​​ 后，默认经过 ​​5秒​​ 进入 ​​半开状态（Half-Open）
   可以通过 circuitBreaker.sleepWindowInMilliseconds 参数调整等待时间。

@HystrixCommand(commandProperties = {@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000" // 10秒后进入半开状态)}
)
public String callService() { ... }

2. Hystrix 的半开状态逻辑是固定不可配置​​的(Resilience4j可以进行配置)，其行为如下：
   ​​探测请求数量​​：仅允许 ​​1次​​ 请求通过。
   ​​熔断关闭条件​​：
   如果探测请求 ​​成功​​，熔断器关闭，恢复服务。
   如果探测请求 ​​失败​​，熔断器重新打开，继续等待下一个 sleepWindowInMilliseconds 周期。

Resilience4j使用

依赖

<!-- Resilience4j 核心模块 -->
<dependency><groupId>io.github.resilience4j</groupId><artifactId>resilience4j-spring-boot2</artifactId><version>1.7.1</version>
</dependency>
<!-- 支持注解方式（需 Spring AOP） -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

使用示例

熔断器

1. 配置

resilience4j:circuitbreaker:instances:userService:failureRateThreshold: 50      # 失败率阈值（%）minimumNumberOfCalls: 5      # 触发统计的最小请求数slidingWindowType: COUNT_BASED  # 滑动窗口类型slidingWindowSize: 10         # 窗口大小（次数）waitDurationInOpenState: 10s  # 熔断持续时间permittedNumberOfCallsInHalfOpenState: 3  # 半开状态允许的请求数ignoreExceptions:             # 忽略特定异常（不触发熔断）- com.example.BusinessException

2. 代码

@Service
public class UserService {@CircuitBreaker(name = "userService", fallbackMethod = "getUserFallback")public User getUser(String userId) {if (userId == null) {throw new RuntimeException("Invalid User ID");}return new User(userId, "Active");}// 降级方法（参数需一致，可添加异常参数）public User getUserFallback(String userId, Exception ex) {return new User(userId, "Fallback");}
}

Resilience4j+Feign Client 实现熔断

1. 配置

resilience4j:circuitbreaker:instances:userService:  # 熔断器实例名（需与 Feign Client 名称对应）failureRateThreshold: 50     # 失败率阈值（%）minimumNumberOfCalls: 5    # 触发统计的最小请求数slidingWindowType: COUNT_BASED  # 滑动窗口类型slidingWindowSize: 10       # 窗口大小（次数）waitDurationInOpenState: 10s  # 熔断持续时间permittedNumberOfCallsInHalfOpenState: 3  # 半开状态允许的请求数recordExceptions:          # 触发熔断的异常类型- java.io.IOException- java.util.concurrent.TimeoutException

2. 代码

@FeignClient(name = "userService",  // 与熔断器实例名一致url = "http://localhost:8081",fallback = UserServiceFallback.class // 直接指定降级类
)
public interface UserServiceClient {@GetMapping("/users/{userId}")User getUser(@PathVariable String userId);
}

3. 熔断降级类

@Component
public class UserServiceFallback implements UserServiceClient {@Overridepublic User getUser(String userId) {// 熔断降级逻辑return new User(userId, "Fallback User");}
}

4. 在降级方法中捕获异常

@Component
public class UserServiceFallback implements UserServiceClient {@Overridepublic User getUser(String userId, Throwable ex) {  // 添加 Throwable 参数log.error("Fallback triggered by: {}", ex.getMessage());return new User(userId, "Fallback User");}
}

重试（Retry）

1. 配置

resilience4j:retry:instances:paymentService:maxAttempts: 3              # 最大重试次数waitDuration: 500ms         # 重试间隔retryExceptions:            # 触发重试的异常类型- java.io.IOException

2. 代码

@Service
public class PaymentService {@Retry(name = "paymentService", fallbackMethod = "processPaymentFallback")public String processPayment(String orderId) {if (Math.random() > 0.3) {throw new IOException("Payment Gateway Error");}return "Payment Success: " + orderId;}public String processPaymentFallback(String orderId, Exception ex) {return "Fallback: " + orderId;}
}

限流（Rate Limiter）​

限制单位时间内的请求速率​​：通过 ​​令牌桶算法​​ 或 ​​漏桶算法​​，控制请求的流量。
​​实现方式​​：
​​令牌桶算法​​：以固定速率生成令牌，请求需获取令牌才能执行。
​​漏桶算法​​：强制请求以恒定速率执行，平滑处理突发流量。

1. 配置

resilience4j:ratelimiter:instances:orderService:limitForPeriod: 5           # 时间窗口内允许的请求数limitRefreshPeriod: 1s      # 时间窗口长度timeoutDuration: 100ms      # 等待令牌的超时时间

2. 代码

@Service
public class OrderService {@RateLimiter(name = "orderService", fallbackMethod = "createOrderFallback")public String createOrder(String productId) {return "Order Created: " + productId;}public String createOrderFallback(String productId, Exception ex) {return "Too Many Requests: " + productId;}
}

隔板（Bulkhead）​

​​限制同一时间的最大并发请求数​​：通过控制 ​​并发执行数量​​，防止资源耗尽

1. 隔板的两种实现
   ​​信号量隔离（SemaphoreBulkhead）​​
   ​​原理​​：基于信号量（Semaphore）控制​​并发请求的最大数量​​。
   ​​行为​​：当并发请求数超过阈值时，立即拒绝新请求（抛出BulkheadFullException），无等待队列。
   ​​适用场景​​：轻量级、低延迟的并发控制，适用于I/O密集型或快速响应的操作。
   ​​线程池隔离（FixedThreadPoolBulkhead，已弃用）​​
   ​​原理​​：通过有界线程池和任务队列限制并发（类似Hystrix的线程隔离）。
   ​​行为​​：任务提交到线程池执行，队列满时拒绝新任务。
   ​​状态​​：Resilience4j官方已弃用此实现，推荐使用信号量隔离或结合其他异步库（如CompletableFuture）管理线程资源。
2. 配置

resilience4j:bulkhead:instances:reportService:maxConcurrentCalls: 10      # 最大并发调用数maxWaitDuration: 10ms      # 等待进入隔板的超时时间

maxWaitDuration：

当隔板的并发请求数已满（达到 maxConcurrentCalls 限制）时，​​新请求可以等待其他请求释放资源的最大时间​​。
​​默认值​​：0（即不等待，直接拒绝请求，抛出 BulkheadFullException）。
​​单位​​：毫秒（例如 Duration.ofSeconds(2) 表示最多等待 2 秒）。

3. 代码

@Service
public class ReportService {@Bulkhead(name = "reportService", fallbackMethod = "generateReportFallback")public String generateReport(String reportId) {return "Report: " + reportId;}public String generateReportFallback(String reportId, Exception ex) {return "System Busy: " + reportId;}
}

组合使用多个容错机制​

@Service
public class ProductService {// 同时应用熔断 + 重试 + 限流@CircuitBreaker(name = "productService", fallbackMethod = "fallback")@Retry(name = "productService", fallbackMethod = "fallback")@RateLimiter(name = "productService", fallbackMethod = "fallback")public String getProduct(String productId) {if (Math.random() > 0.5) {throw new RuntimeException("Service Error");}return "Product: " + productId;}public String fallback(String productId, Exception ex) {return "Fallback: " + productId;}
}

Hystrix vs Resilience4j

1. 核心特性对比​
   
2. 功能深度对比​
   熔断器
   
   容错模式​
   
3. 性能对比​
   资源消耗​​
   ​​Hystrix​​：线程池隔离需要为每个服务分配独立线程池，线程上下文切换开销大，适合资源充足的中型系统。
   ​​Resilience4j​​：信号量隔离无需创建线程，内存占用低，适合高并发场景和云原生环境。
   吞吐量测试​​
   ​​场景​​：1000并发请求，熔断触发条件相同。
   ​​结果​​：
   Resilience4j 吞吐量比 Hystrix 高 ​​30%~50%​​。
   Resilience4j 的 GC 停顿时间更短。