// TECHNICALLY OK: Retry doesn't maintain state between calls
Retry sharedRetry = Retry.ofDefaults("shared");

// BETTER: Unique instances provide better metrics and monitoring
Retry paymentRetry = Retry.ofDefaults("paymentService");
Retry inventoryRetry = Retry.ofDefaults("inventoryService");

// Now you can track:
// - How many retry attempts failed for paymentService specifically
// - How many retry attempts failed for inventoryService specifically

// You have 3 backend services to protect
public class ServiceOrchestrator {

    // Payment Service protection
    private final CircuitBreaker paymentCB = CircuitBreaker.ofDefaults("paymentService");
    private final Retry paymentRetry = Retry.ofDefaults("paymentService");
    private final Bulkhead paymentBulkhead = Bulkhead.ofDefaults("paymentService");

    // Inventory Service protection
    private final CircuitBreaker inventoryCB = CircuitBreaker.ofDefaults("inventoryService");
    private final Retry inventoryRetry = Retry.ofDefaults("inventoryService");
    private final Bulkhead inventoryBulkhead = Bulkhead.ofDefaults("inventoryService");

    // Notification Service protection
    private final CircuitBreaker notificationCB = CircuitBreaker.ofDefaults("notificationService");
    private final Retry notificationRetry = Retry.ofDefaults("notificationService");

    public Order processOrder(OrderRequest request) {
        // Each service call is protected by its own set of resilience instances

        // Call payment service
        Supplier<PaymentResult> paymentCall = () -> paymentService.charge(request);
        PaymentResult payment = Decorators.ofSupplier(paymentCall)
            .withCircuitBreaker(paymentCB)
            .withRetry(paymentRetry)
            .withBulkhead(paymentBulkhead)
            .decorate()
            .get();

        // Call inventory service
        Supplier<InventoryResult> inventoryCall = () -> inventoryService.reserve(request);
        InventoryResult inventory = Decorators.ofSupplier(inventoryCall)
            .withCircuitBreaker(inventoryCB)
            .withRetry(inventoryRetry)
            .withBulkhead(inventoryBulkhead)
            .decorate()
            .get();

        // Call notification service (demonstrates circuit isolation: the notification circuit breaker remains independent of the payment circuit breaker, even if payment opens its circuit in other calls)
        Runnable notificationCall = () -> notificationService.send(request);
        Decorators.ofRunnable(notificationCall)
            .withCircuitBreaker(notificationCB)
            .withRetry(notificationRetry)
            .decorate()
            .run();

        return new Order(payment, inventory);
    }
}