2. Padrões de Resiliência

package boxoffice.order.payment;

import java.math.BigDecimal;
import java.util.UUID;

public record PaymentRequest(UUID orderId, BigDecimal amount) {
}

package boxoffice.order.payment;

import java.util.UUID;

/** status: AUTHORIZED or DECLINED */
public record PaymentResponse(UUID id, UUID orderId, String status) {
}

package boxoffice.order.payment;

import java.time.Duration;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClient;

@Component
public class PaymentClient {

    private final RestClient http;

    public PaymentClient(RestClient.Builder builder,
                         @Value("${boxoffice.payment.url}") String url,
                         @Value("${boxoffice.payment.connect-timeout}") Duration connectTimeout,
                         @Value("${boxoffice.payment.read-timeout}") Duration readTimeout) {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(connectTimeout);
        factory.setReadTimeout(readTimeout); // 0 = wait forever (the "before" experiment)
        this.http = builder.baseUrl(url).requestFactory(factory).build();
    }

    public PaymentResponse charge(UUID orderId, java.math.BigDecimal amount) {
        return http.post()
                .uri("/payments")
                .header("Idempotency-Key", "order-" + orderId) // same key on every retry
                .body(new PaymentRequest(orderId, amount))
                .retrieve()
                .body(PaymentResponse.class);
    }
}

package boxoffice.order.payment;

import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import java.math.BigDecimal;
import java.util.UUID;
import org.springframework.stereotype.Component;

/**
 * Default aspect order: Retry ( CircuitBreaker ( Bulkhead ( call ) ) ).
 * The fallback sits on the OUTERMOST layer, so it runs only after the retries are exhausted,
 * when the circuit is open or when the bulkhead is full.
 */
@Component
public class PaymentGateway {

    private final PaymentClient client;

    public PaymentGateway(PaymentClient client) {
        this.client = client;
    }

    @Retry(name = "payment", fallbackMethod = "unavailable")
    @CircuitBreaker(name = "payment")
    @Bulkhead(name = "payment")
    public PaymentResponse charge(UUID orderId, BigDecimal amount) {
        return client.charge(orderId, amount);
    }

    /** The "before" path of the experiments: no Resilience4j at all. */
    public PaymentResponse chargeUnprotected(UUID orderId, BigDecimal amount) {
        return client.charge(orderId, amount);
    }

    /** Same parameters + the exception: Resilience4j finds it by name and signature. */
    private PaymentResponse unavailable(UUID orderId, BigDecimal amount, Throwable cause) {
        throw new PaymentUnavailableException(cause);
    }
}

package boxoffice.order.payment;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

/** Fast, explicit failure: the fan sees "try again in a moment", not a 60-second spinner. */
@ResponseStatus(HttpStatus.SERVICE_UNAVAILABLE)
public class PaymentUnavailableException extends RuntimeException {

    public PaymentUnavailableException(Throwable cause) {
        super("payment temporarily unavailable: " + cause.getClass().getSimpleName(), cause);
    }
}

package boxoffice.order;

import boxoffice.order.OrderProperties.NotifyMode;
import boxoffice.order.outbox.Outbox;
import boxoffice.order.payment.PaymentGateway;
import boxoffice.order.payment.PaymentResponse;
import java.time.Instant;
import java.util.Optional;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.server.ResponseStatusException;

@Service
public class OrderService {

    public record PlaceResult(OrderView order, boolean created) {
    }

    private static final String SELECT = """
            SELECT id, show_id, hold_id, customer_email, amount, status, created_at
            FROM orders
            """;

    private final JdbcClient jdbc;
    private final Outbox outbox;
    private final NotificationClient notifications;
    private final OrderProperties props;
    private final PaymentGateway payments;
    private final TransactionTemplate tx;
    private final boolean resilience;

    public OrderService(JdbcClient jdbc, Outbox outbox, NotificationClient notifications,
                        OrderProperties props, PaymentGateway payments, TransactionTemplate tx,
                        @Value("${boxoffice.payment.resilience:true}") boolean resilience) {
        this.jdbc = jdbc;
        this.outbox = outbox;
        this.notifications = notifications;
        this.props = props;
        this.payments = payments;
        this.tx = tx;
        this.resilience = resilience;
    }

    @Transactional
    public PlaceResult place(OrderRequest req) {
        int inserted = jdbc.sql("""
                INSERT INTO orders (id, show_id, hold_id, customer_email, amount, status)
                VALUES (?, ?, ?, ?, ?, 'PENDING_PAYMENT')
                ON CONFLICT (hold_id) DO NOTHING
                """)
                .params(UUID.randomUUID(), req.showId(), req.holdId(), req.customerEmail(), req.amount())
                .update();

        OrderView order = jdbc.sql(SELECT + " WHERE hold_id = ?")
                .param(req.holdId())
                .query(OrderView.class)
                .single();

        if (inserted == 0) {
            return new PlaceResult(order, false);
        }

        OrderEvent event = OrderEvent.placed(order);
        if (props.notifyMode() == NotifyMode.SYNC) {
            notifications.send(event);
        } else {
            outbox.append(event.eventId(), "order", order.id(), event.eventType(), event);
        }
        return new PlaceResult(order, true);
    }

    /** No @Transactional here: never hold a DB connection during a remote call. */
    public OrderView pay(UUID id) {
        OrderView order = find(id).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        if (!"PENDING_PAYMENT".equals(order.status())) {
            return order; // already paid or cancelled: paying twice is a no-op
        }
        PaymentResponse payment = resilience
                ? payments.charge(order.id(), order.amount())
                : payments.chargeUnprotected(order.id(), order.amount());
        String next = "AUTHORIZED".equals(payment.status()) ? "CONFIRMED" : "CANCELLED";

        tx.executeWithoutResult(status -> {
            int changed = jdbc.sql("UPDATE orders SET status = ? WHERE id = ? AND status = 'PENDING_PAYMENT'")
                    .params(next, id)
                    .update();
            if (changed == 1) {
                String type = "CONFIRMED".equals(next) ? "OrderConfirmed" : "OrderCancelled";
                OrderEvent event = new OrderEvent(UUID.randomUUID(), type, order.id(), order.showId(),
                        order.holdId(), order.customerEmail(), order.amount(), Instant.now());
                outbox.append(event.eventId(), "order", order.id(), type, event);
            }
        });
        return find(id).orElseThrow();
    }

    public Optional<OrderView> find(UUID id) {
        return jdbc.sql(SELECT + " WHERE id = ?").param(id).query(OrderView.class).optional();
    }
}

package boxoffice.order;

import boxoffice.order.waitingroom.WaitingRoom;
import jakarta.validation.Valid;
import java.net.URI;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
@RequestMapping("/orders")
public class OrderController {

    private final OrderService orders;
    private final WaitingRoom waitingRoom;

    public OrderController(OrderService orders, WaitingRoom waitingRoom) {
        this.orders = orders;
        this.waitingRoom = waitingRoom;
    }

    @PostMapping
    public ResponseEntity<OrderView> place(
            @Valid @RequestBody OrderRequest req,
            @RequestHeader(name = "X-Admission-Ticket", required = false) String ticket) {
        if (!waitingRoom.mayEnter(req.showId(), ticket)) {
            throw new ResponseStatusException(HttpStatus.FORBIDDEN,
                    "on-sale in progress: join /orders/waiting-room/" + req.showId() + "/join first");
        }
        OrderService.PlaceResult result = orders.place(req);
        if (!result.created()) {
            return ResponseEntity.ok(result.order());
        }
        return ResponseEntity.created(URI.create("/orders/" + result.order().id())).body(result.order());
    }

    @GetMapping("/{id}")
    public OrderView get(@PathVariable UUID id) {
        return orders.find(id).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    @PostMapping("/{id}/pay")
    public OrderView pay(@PathVariable UUID id) {
        return orders.pay(id);
    }
}