Hystrix的替代 - Resilience4j

一：Resilience4j概述

Resilience4j是新一代的熔断限流框架，可以完美替代Hystrix!!

Resilience4j 是一个专为 Java 应用设计的轻量级容错库，旨在帮助开发者在微服务架构中实现健壮的错误处理和系统弹性。

它提供了一系列模块化的组件，如断路器（Circuit Breaker）、重试（Retry）、限流器（Rate Limiter）、隔离器（Bulkhead）、缓存（Cache）以及时间器（TimeLimiter），这些组件可以单独使用或组合使用，以应对不同类型的故障场景。

Resilience4j 以其简单易用、灵活配置和良好的性能表现，成为许多 Java 开发者在构建高可用系统时的首选工具。

1：为什么选择Resilience4j

轻量级且模块化：Resilience4j 采用模块化设计，开发者可以根据实际需求选择所需的功能模块，避免引入不必要的依赖，保持项目的轻量性。

函数式编程支持：Resilience4j 完全基于 Java 8 的函数式编程理念，能够与现代 Java 应用无缝集成，提升代码的可读性和可维护性。

易于配置和扩展：通过简单的配置文件或代码方式，开发者可以轻松定制各个模块的行为。此外，Resilience4j 提供丰富的扩展点，允许用户根据具体需求进行自定义。

良好的集成能力：Resilience4j 能够与 Spring Boot 等主流框架良好集成，简化了在现有项目中引入容错机制的过程。同时，它也兼容多种监控工具，方便进行性能监控和故障诊断。

活跃的社区和文档支持：Resilience4j 拥有活跃的开源社区，提供详尽的文档和丰富的示例，帮助开发者快速上手并解决实际问题。

2：和Hystrix的对比

在众多容错框架中，Resilience4j 与 Netflix 的 Hystrix 是最具代表性的两者。

虽然 Hystrix 曾经是业界广泛使用的容错解决方案，但由于 Netflix 已停止对 Hystrix 的维护，开发者逐渐转向其他替代方案，其中 Resilience4j 脱颖而出，成为热门选择。

与 Hystrix 相比，Resilience4j 具有以下优势：

• 纯 Java 实现：Resilience4j 完全基于 Java 8 开发，不依赖于其他外部库，减少了项目的复杂性和潜在的兼容性问题。

• 模块化设计：不同于 Hystrix 的一体化设计，Resilience4j 提供独立的模块，开发者可以根据需求灵活组合，优化系统性能和资源使用。

• 更好的性能表现：Resilience4j 通过优化内部实现和减少资源消耗，在高并发场景下表现出更优的性能。

• 更活跃的维护和社区支持：作为一个新兴的开源项目，Resilience4j 拥有更为活跃的开发社区和持续的更新迭代，确保其能够及时响应和解决用户需求和问题。

二：Resilience4j核心概念

1：断路器circuit Breaker

断路器模式源自电气工程中的断路器概念，用于防止故障在系统中蔓延。

Resilience4j 的断路器监控服务的调用情况，当检测到一定比例的失败后，断路器会切换到“断开”状态，暂时阻断对目标服务的调用，避免进一步的错误。

• 状态管理：断路器有三种状态——关闭（Closed）、打开（Open）和半开（Half-Open）。

  • 在关闭状态下，所有请求正常通过；
  • 在打开状态下，所有请求被拒绝；
  • 在半开状态下，部分请求被允许以测试服务恢复情况。

• 失败阈值：可以配置在多长时间内失败的请求达到多少比例时触发断路器。

• 恢复机制：断路器在一段时间后会尝试恢复，进入半开状态，以检测服务是否恢复正常。

2：重试Retry

重试机制用于在调用失败时自动重新尝试执行，以应对暂时性的故障或网络波动。

Resilience4j 的重试模块允许开发者配置重试的次数、间隔时间以及重试的条件。

• 重试次数：设置最大重试次数，防止无限重试导致资源耗尽。
• 重试间隔：配置重试之间的等待时间，可以是固定间隔或指数退避策略。
• 可重试的异常：指定哪些异常类型应触发重试操作，避免对不可恢复的错误进行重试。

3：限流器Rate Limiter

限流器用于控制对资源的访问速率，防止系统过载。

Resilience4j 的限流器通过限制单位时间内允许的请求数量，确保系统在高负载下仍能稳定运行。

• 限流策略：支持固定窗口和滑动窗口等不同的限流策略，以适应不同的应用场景。
• 等待时间：配置请求在限流器限制下的等待时间，超过等待时间的请求可以被拒绝或抛出异常。
• 令牌桶算法：基于令牌桶算法实现限流，灵活控制请求速率。

4：隔离器Bulkhead

隔离器模式类似于船舶的舱壁设计，用于将系统划分为多个独立的部分，以防止某个部分的故障影响整个系统。

Resilience4j 的隔离器通过限制并发调用的数量，确保关键资源的可用性。

• 并发限制：配置每个隔离器的最大并发调用数，防止资源被耗尽。
• 线程池隔离：可以为不同的服务或模块配置独立的线程池，隔离不同部分的负载。
• 资源分配：合理分配资源，确保高优先级服务的稳定性。

5：缓存Cache

缓存模块用于存储请求的响应结果，减少对后端服务的频繁调用，提高系统的响应速度和可用性。

Resilience4j 的缓存模块可以与断路器和重试机制结合使用，优化容错策略。

• 缓存策略：支持基于时间的过期策略和基于容量的缓存淘汰策略。
• 缓存命中：提高缓存命中率，减少对后端服务的请求次数。
• 集成简便：与现有缓存框架（如 Caffeine、Guava）无缝集成，灵活配置缓存行为。

6：时间器Time Limiter

时间器用于限制调用的最大执行时间，防止长时间阻塞导致系统资源被占用。

Resilience4j 的时间器通过设置超时时间，当调用超过指定时间后自动中断。

• 超时时间：配置调用的最大允许时间，超过则抛出超时异常。
• 异步支持：支持对异步操作进行时间限制，提升系统的响应性。
• 组合使用：可以与断路器、重试等其他模块结合使用，构建更复杂的容错策略。

三：Resilience4j快速入门

1：依赖引入

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Resilience4j Spring Boot Starter -->
    <dependency>
        <groupId>io.github.resilience4j</groupId>
        <artifactId>resilience4j-spring-boot2</artifactId>
        <version>1.7.1</version>
    </dependency>

    <!-- 可选：Resilience4j Micrometer 集成，用于监控 -->
    <dependency>
        <groupId>io.github.resilience4j</groupId>
        <artifactId>resilience4j-micrometer</artifactId>
        <version>1.7.1</version>
    </dependency>

    <!-- 可选：Spring Boot Actuator，用于监控和管理 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

2：基本配置说明

在添加依赖后，需要在 application.yml 或 application.properties 文件中进行基本配置。

resilience4j:
  circuitbreaker:
    instances:
      demoCircuitBreaker: # 断路器的名称，可以根据需要命名
        registerHealthIndicator: true # 是否注册健康指示器，用于监控。
        slidingWindowSize: 10 # 滑动窗口大小，用于统计失败率。
        minimumNumberOfCalls: 5 # 触发断路器前的最小调用次数
        failureRateThreshold: 50 # 失败率阈值，超过该值断路器将打开
        waitDurationInOpenState: 10000 # 10 秒
        permittedNumberOfCallsInHalfOpenState: 3 # 半开状态下允许的调用次数。
        automaticTransitionFromOpenToHalfOpenEnabled: true # 是否自动从打开状态过渡到半开状态。

3：代码中的基本使用

package com.example.resilience4jdemo;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    private static final String CIRCUIT_BREAKER_NAME = "demoCircuitBreaker";

    @GetMapping("/callService")
    // 注意下面这个注解 name表示使用的是那个名称的断路器的配置
    // fallback表示触发断路之后如何返回降级消息
    @CircuitBreaker(name = CIRCUIT_BREAKER_NAME, fallbackMethod = "fallback")
    public String callService() {
        // 模拟服务调用
        if (Math.random() < 0.5) {
            throw new RuntimeException("服务调用失败");
        }
        return "服务调用成功";
    }

    public String fallback(Throwable t) {
        return "服务暂时不可用，请稍后再试。";
    }
}

四：核心模块详解

1：断路器详解-熔断

1.1：马丁福勒的熔断三态

断路器主要有三种状态：

• 关闭（Closed）：所有请求正常通过，断路器监控请求的成功与失败。

• 打开（Open）：当失败率超过预设阈值时，断路器切换到打开状态，阻断对目标服务的所有请求，立即返回失败，避免系统资源的浪费。

• 半开（Half-Open）：在断路器打开一段时间后，进入半开状态，允许有限数量的请求通过，以测试目标服务是否恢复正常。

1.2：基础功能的使用

resilience4j:
  circuitbreaker:
    instances:
      demoCircuitBreaker:
        registerHealthIndicator: true
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        failureRateThreshold: 50
        waitDurationInOpenState: 10000 # 10 秒
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        recordExceptions:
          - java.lang.RuntimeException
        ignoreExceptions:
          - java.lang.IllegalArgumentException

package com.example.resilience4jdemo;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {
    private static final String CIRCUIT_BREAKER_NAME = "demoCircuitBreaker";

    @GetMapping("/callService")
    @CircuitBreaker(name = CIRCUIT_BREAKER_NAME, fallbackMethod = "fallback")
    public String callService() {
        // 模拟服务调用
        if (Math.random() < 0.5) {
            throw new RuntimeException("服务调用失败");
        }
        return "服务调用成功";
    }

    public String fallback(Throwable t) {
        return "服务暂时不可用，请稍后再试。";
    }
}

1.3：状态管理与事件监听

Resilience4j 提供了丰富的事件监听机制，允许开发者监控断路器的状态变化和重要事件。

添加事件监听器：

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.circuitbreaker.event.CircuitBreakerOnStateTransitionEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CircuitBreakerEventListener {
    @Autowired
    public CircuitBreakerEventListener(CircuitBreakerRegistry circuitBreakerRegistry) {
        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("demoCircuitBreaker");
        circuitBreaker.getEventPublisher()
            .onStateTransition(this::handleStateTransition);
    }

    private void handleStateTransition(CircuitBreakerOnStateTransitionEvent event) {
        System.out.println("断路器状态变化: " + event.getStateTransition());
    }
}

2：重试详解-重试

2.1：工作原理

重试机制用于在调用失败时自动重新尝试执行，适用于处理暂时性的故障或网络波动。

Resilience4j 的重试模块允许开发者配置重试的次数、间隔时间以及重试的条件，从而提高操作的成功率。

2.2：基本功能的使用

resilience4j:
  retry:
    instances:
      demoRetry:
        maxAttempts: 3 # 最大重试次数
        waitDuration: 2000 # 每次重试等待的间隔 2 秒
        retryExceptions:
          - java.io.IOException
        ignoreExceptions:
          - java.lang.IllegalArgumentException
        exponentialBackoff:
          multiplier: 1.5
          maxWaitDuration: 10000 # 10 秒

package com.example.resilience4jdemo;

import io.github.resilience4j.retry.annotation.Retry;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RetryController {

    private static final String RETRY_NAME = "demoRetry";

    @GetMapping("/retryService")
    @Retry(name = RETRY_NAME, fallbackMethod = "retryFallback")
    public String retryService() {
        // 模拟可能失败的操作
        if (Math.random() < 0.7) {
            throw new RuntimeException("重试服务调用失败");
        }
        return "重试服务调用成功";
    }

    public String retryFallback(Throwable t) {
        return "重试服务暂时不可用，请稍后再试。";
    }
}

2.3：重试策略

Resilience4j 支持多种重试策略，包括固定间隔、指数退避等。

固定间隔重试：

resilience4j:
  retry:
    instances:
      fixedIntervalRetry:
        maxAttempts: 5
        waitDuration: 1000 # 1 秒

指数退避重试：

resilience4j:
  retry:
    instances:
      exponentialBackoffRetry:
        maxAttempts: 5
        waitDuration: 1000 # 初始等待时间为1秒
        exponentialBackoff:
          multiplier: 2.0
          maxWaitDuration: 8000 # 最大等待时间为8秒

3：限流器详解-限流

3.1：工作原理

限流器用于控制对资源的访问速率，防止系统过载。

Resilience4j 的限流器通过限制单位时间内允许的请求数量，确保系统在高负载下依然能够稳定运行。

3.2：基本功能的使用

resilience4j:
  ratelimiter:
    instances:
      demoRateLimiter:
        limitForPeriod: 10 
        limitRefreshPeriod: 1s
        timeoutDuration: 500 # 毫秒

package com.example.resilience4jdemo;

import io.github.resilience4j.ratelimiter.annotation.RateLimiter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RateLimiterController {

    private static final String RATE_LIMITER_NAME = "demoRateLimiter";

    @GetMapping("/rateLimitedService")
    @RateLimiter(name = RATE_LIMITER_NAME, fallbackMethod = "rateLimiterFallback")
    public String rateLimitedService() {
        return "限流服务调用成功";
    }

    public String rateLimiterFallback(Throwable t) {
        return "请求过于频繁，请稍后再试。";
    }
}

4：隔离器详解-并发

4.1：工作原理

隔离器模式类似于船舶的舱壁设计，用于将系统划分为多个独立的部分，以防止某个部分的故障影响整个系统。

Resilience4j 的隔离器通过限制并发调用的数量，确保关键资源的可用性。

4.2：基本功能的使用

resilience4j:
  bulkhead:
    instances:
      demoBulkhead:
        maxConcurrentCalls: 5 # 最大并发调用数，超过该数目的请求将被限制。
        maxWaitDuration: 0 # 请求在等待队列中的最大等待时间，超时后请求将被拒绝

package com.example.resilience4jdemo;

import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BulkheadController {

    private static final String BULKHEAD_NAME = "demoBulkhead";

    @GetMapping("/bulkheadService")
    @Bulkhead(name = BULKHEAD_NAME, fallbackMethod = "bulkheadFallback")
    public String bulkheadService() {
        // 模拟长时间运行的操作
        try {
            Thread.sleep(3000); // 3 秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "隔离器服务调用成功";
    }

    public String bulkheadFallback(Throwable t) {
        return "系统繁忙，请稍后再试。";
    }
}

5：缓存详解-缓存

5.1：工作原理

缓存模块用于存储请求的响应结果，减少对后端服务的频繁调用，提高系统的响应速度和可用性。

通过缓存，系统可以快速返回已缓存的数据，降低延迟和资源消耗。

5.2：基本功能的使用

resilience4j:
  cache:
    instances:
      demoCache:
        cacheName: "demoCache"
        timeToLive: 60000 # 缓存条目在创建后60秒过期。
        maxSize: 1000 # 缓存最多存储1000个条目，超过后自动移除最久未使用的条目。

package com.example.resilience4jdemo;

import io.github.resilience4j.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CacheController {

    @GetMapping("/cacheService")
    @Cacheable(name = "demoCache", key = "#id")
    public String cacheService(@RequestParam("id") String id) {
        // 模拟耗时操作
        try {
            Thread.sleep(2000); // 2 秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "缓存服务响应，ID: " + id;
    }
}

5.3：和其他缓存框架的集成

Resilience4j 的缓存模块可以与多种缓存框架（如 Caffeine、Guava）无缝集成，提供灵活的缓存实现。

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.0.5</version>
</dependency>

import com.github.benmanes.caffeine.cache.Caffeine;
import io.github.resilience4j.cache.Cache;
import io.github.resilience4j.cache.CacheRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
public class CacheConfig {

    @Bean
    public CacheRegistry cacheRegistry() {
        CacheRegistry cacheRegistry = CacheRegistry.ofDefaults();
        Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
            .expireAfterWrite(60, TimeUnit.SECONDS)
            .maximumSize(1000);
        // 声明使用的缓存时caffeine
        cacheRegistry.addCache("demoCache", Cache.of(caffeine));
        return cacheRegistry;
    }
}

6：时间器详解-超时

6.1：工作原理

时间器用于限制调用的最大执行时间，防止长时间阻塞导致系统资源被占用。

Resilience4j 的时间器通过设置超时时间，当调用超过指定时间后自动中断，确保系统的响应性。

6.2：基本功能的使用

resilience4j:
  timelimiter:
    instances:
      demoTimeLimiter:
        timeoutDuration: 3s # 设置为3秒，意味着如果调用时间超过3秒，将触发超时处理。
        cancelRunningFuture: true # 设置为true，表示在超时发生时，尝试取消正在执行的异步任务。

package com.example.resilience4jdemo;

import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@RestController
public class TimeLimiterController {

    private static final String TIME_LIMITER_NAME = "demoTimeLimiter";

    @GetMapping("/timeLimitedService")
    @TimeLimiter(name = TIME_LIMITER_NAME, fallbackMethod = "timeLimiterFallback")
    public CompletableFuture<String> timeLimitedService() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟长时间运行的操作
            try {
                Thread.sleep(5000); // 5 秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "时间器服务调用成功";
        });
    }

    public CompletableFuture<String> timeLimiterFallback(Throwable t) {
        return CompletableFuture.completedFuture("请求超时，请稍后再试。");
    }
}

五：综合应用

在实际项目中，Resilience4j 的各个模块常常需要组合使用，以应对复杂的容错需求。

1：断路器 + 重试

服务调用可能出现暂时性故障，使用重试增加成功率，同时使用断路器防止故障蔓延。

resilience4j:
  circuitbreaker:
    instances:
      serviceCircuitBreaker:
        failureRateThreshold: 50
        waitDurationInOpenState: 10000
  retry:
    instances:
      serviceRetry:
        maxAttempts: 3
        waitDuration: 2000

2：限流器 + 隔离器

控制请求速率，确保系统在高负载下仍能稳定运行。

resilience4j:
  ratelimiter:
    instances:
      serviceRateLimiter:
        limitForPeriod: 20
        limitRefreshPeriod: 1s
  bulkhead:
    instances:
      serviceBulkhead:
        maxConcurrentCalls: 10
        maxWaitDuration: 500

3：断路器 + 时间器

限制服务调用的最大执行时间，同时监控失败率

resilience4j:
  circuitbreaker:
    instances:
      serviceCircuitBreaker:
        failureRateThreshold: 40
        waitDurationInOpenState: 15000
  timelimiter:
    instances:
      serviceTimeLimiter:
        timeoutDuration: 2s
        cancelRunningFuture: true

4：综合使用代码

resilience4j:
  circuitbreaker:
    instances:
      demoCircuitBreaker:
        registerHealthIndicator: true
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        failureRateThreshold: 50
        waitDurationInOpenState: 10000 # 10 秒
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        recordExceptions:
          - java.lang.RuntimeException
        ignoreExceptions:
          - java.lang.IllegalArgumentException

  retry:
    instances:
      demoRetry:
        maxAttempts: 3
        waitDuration: 2000 # 2 秒
        retryExceptions:
          - java.io.IOException
        ignoreExceptions:
          - java.lang.IllegalArgumentException
        exponentialBackoff:
          multiplier: 1.5
          maxWaitDuration: 10000 # 10 秒

  ratelimiter:
    instances:
      demoRateLimiter:
        limitForPeriod: 10
        limitRefreshPeriod: 1s
        timeoutDuration: 500 # 毫秒

  bulkhead:
    instances:
      demoBulkhead:
        maxConcurrentCalls: 5
        maxWaitDuration: 0 # 不等待，直接拒绝超出的请求

  timelimiter:
    instances:
      demoTimeLimiter:
        timeoutDuration: 3s
        cancelRunningFuture: true

package com.example.resilience4jdemo;

import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.ratelimiter.annotation.RateLimiter;
import io.github.resilience4j.retry.annotation.Retry;
import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@RestController
public class Resilience4jController {

    private static final String CIRCUIT_BREAKER_NAME = "demoCircuitBreaker";
    private static final String RETRY_NAME = "demoRetry";
    private static final String RATE_LIMITER_NAME = "demoRateLimiter";
    private static final String BULKHEAD_NAME = "demoBulkhead";
    private static final String TIME_LIMITER_NAME = "demoTimeLimiter";

    /**
     * 断路器示例
     */
    @GetMapping("/circuitBreakerService")
    @CircuitBreaker(name = CIRCUIT_BREAKER_NAME, fallbackMethod = "circuitBreakerFallback")
    public String circuitBreakerService() {
        // 模拟服务调用，随机失败
        if (Math.random() < 0.5) {
            throw new RuntimeException("服务调用失败");
        }
        return "断路器服务调用成功";
    }

    public String circuitBreakerFallback(Throwable t) {
        return "断路器服务暂时不可用，请稍后再试。";
    }

    /**
     * 重试示例
     */
    @GetMapping("/retryService")
    @Retry(name = RETRY_NAME, fallbackMethod = "retryFallback")
    public String retryService() {
        // 模拟可能失败的操作
        if (Math.random() < 0.7) {
            throw new RuntimeException("重试服务调用失败");
        }
        return "重试服务调用成功";
    }

    public String retryFallback(Throwable t) {
        return "重试服务暂时不可用，请稍后再试。";
    }

    /**
     * 限流器示例
     */
    @GetMapping("/rateLimitedService")
    @RateLimiter(name = RATE_LIMITER_NAME, fallbackMethod = "rateLimiterFallback")
    public String rateLimitedService() {
        return "限流服务调用成功";
    }

    public String rateLimiterFallback(Throwable t) {
        return "请求过于频繁，请稍后再试。";
    }

    /**
     * 隔离器示例
     */
    @GetMapping("/bulkheadService")
    @Bulkhead(name = BULKHEAD_NAME, fallbackMethod = "bulkheadFallback")
    public String bulkheadService() {
        // 模拟长时间运行的操作
        try {
            Thread.sleep(3000); // 3 秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "隔离器服务调用成功";
    }

    public String bulkheadFallback(Throwable t) {
        return "系统繁忙，请稍后再试。";
    }

    /**
     * 时间器示例
     */
    @GetMapping("/timeLimitedService")
    @TimeLimiter(name = TIME_LIMITER_NAME, fallbackMethod = "timeLimiterFallback")
    public CompletableFuture<String> timeLimitedService() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟长时间运行的操作
            try {
                Thread.sleep(5000); // 5 秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "时间器服务调用成功";
        });
    }

    public CompletableFuture<String> timeLimiterFallback(Throwable t) {
        return CompletableFuture.completedFuture("请求超时，请稍后再试。");
    }

    /**
     * 综合使用示例：断路器 + 重试 + 限流器 + 隔离器 + 时间器
     */
    @GetMapping("/combinedService")
    @CircuitBreaker(name = CIRCUIT_BREAKER_NAME, fallbackMethod = "combinedFallback")
    @Retry(name = RETRY_NAME)
    @RateLimiter(name = RATE_LIMITER_NAME)
    @Bulkhead(name = BULKHEAD_NAME)
    @TimeLimiter(name = TIME_LIMITER_NAME)
    public CompletableFuture<String> combinedService() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟服务调用
            try {
                Thread.sleep(1000); // 1 秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "综合容错服务调用成功";
        });
    }

    public CompletableFuture<String> combinedFallback(Throwable t) {
        return CompletableFuture.completedFuture("综合容错服务暂时不可用，请稍后再试。");
    }
}