<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-vertx</artifactId>
    <version>2.0.0</version>
</dependency>

VertxOptions options = new VertxOptions()
    .setWorkerPoolSize(10); // 專用Worker線程池
Vertx vertx = Vertx.vertx(options);

// 配置斷路器
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50) // 失敗率閾值50%
    .waitDurationInOpenState(Duration.ofSeconds(5)) // Open狀態(tài)持續(xù)時(shí)間
    .permittedNumberOfCallsInHalfOpenState(3) // 半開狀態(tài)允許的請求數(shù)
    .build();

CircuitBreaker circuitBreaker = CircuitBreaker.of("myService", config);

// 在Worker線程中執(zhí)行服務(wù)調(diào)用
vertx.executeBlocking(promise -> {
    try {
        String result = circuitBreaker.executeSupplier(() -> {
            // 模擬阻塞操作（如HTTP請求）
            Thread.sleep(1000);
            return "Success";
        });
        promise.complete(result);
    } catch (Exception e) {
        promise.fail(e);
    }
}, false, res -> {
    if (res.succeeded()) {
        System.out.println("Result: " + res.result());
    } else {
        System.out.println("Failed: " + res.cause().getMessage());
    }
});

// 使用Vertx的Future.timeout（底層由Event Loop線程調(diào)度，但業(yè)務(wù)邏輯在Worker線程中）
Future<String> future = vertx.executeBlocking(promise -> {
    try {
        // 模擬長時(shí)間操作
        Thread.sleep(2000);
        promise.complete("Done");
    } catch (InterruptedException e) {
        promise.fail(e);
    }
}, false);

// 設(shè)置超時(shí)（獨(dú)立線程管理）
future.onComplete(ar -> {
    if (ar.failed() && ar.cause() instanceof TimeoutException) {
        System.out.println("Operation timed out");
    }
});

// 更推薦的方式：使用Resilience4j的TimeLimiter（完全獨(dú)立線程）
TimeLimiter timeLimiter = TimeLimiter.of(Duration.ofSeconds(1));
CompletableFuture<String> timedFuture = timeLimiter.executeFutureSupplier(() -> 
    CompletableFuture.supplyAsync(() -> {
        // 在Worker線程中執(zhí)行
        try {
            Thread.sleep(2000);
            return "Done";
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }, vertx.getOrCreateContext().owner().newInstance());
);

timedFuture.whenComplete((result, ex) -> {
    if (ex != null) {
        System.out.println("Timed out or failed: " + ex.getMessage());
    } else {
        System.out.println("Result: " + result);
    }
});

// 限流配置
RateLimiterConfig rateLimiterConfig = RateLimiterConfig.custom()
    .limitForPeriod(5) // 每秒允許的請求數(shù)
    .limitRefreshPeriod(Duration.ofSeconds(1))
    .timeoutDuration(Duration.ofMillis(100)) // 獲取令牌超時(shí)時(shí)間
    .build();

RateLimiter rateLimiter = RateLimiter.of("myService", rateLimiterConfig);

// 重試配置
RetryConfig retryConfig = RetryConfig.custom()
    .maxAttempts(3)
    .waitDuration(Duration.ofMillis(500))
    .build();

Retry retry = Retry.of("myService", retryConfig);

// 組合使用（限流 + 重試 + 斷路器）
Supplier<String> decoratedSupplier = Retry.decorateSupplier(
    retry,
    RateLimiter.decorateSupplier(
        rateLimiter,
        CircuitBreaker.decorateSupplier(
            circuitBreaker,
            () -> {
                // 在Worker線程中執(zhí)行
                if (Math.random() > 0.7) {
                    throw new RuntimeException("Random failure");
                }
                return "Success";
            }
        )
    )
);

vertx.executeBlocking(promise -> {
    try {
        String result = decoratedSupplier.get();
        promise.complete(result);
    } catch (Exception e) {
        promise.fail(e);
    }
}, false, res -> {
    if (res.succeeded()) {
        System.out.println("Final result: " + res.result());
    } else {
        System.out.println("Final failure: " + res.cause().getMessage());
    }
});