Architecture Hexagonale
Ports, Adapters et inversion de dépendances.

/** Port entrant : cas d'usage "passer une commande". */
public interface PlaceOrderUseCase {

    OrderConfirmation placeOrder(PlaceOrderCommand command);
}

/** Commande portant les données nécessaires. */
public record PlaceOrderCommand(
    CustomerId customerId,
    List<OrderLineRequest> lines
) {}

/** Port sortant : persistance des commandes. */
public interface OrderRepository {

    void save(Order order);

    Optional<Order> findById(OrderId id);

    List<Order> findByCustomer(CustomerId customerId);
}

/** Port sortant : notification de paiement. */
public interface PaymentGateway {

    PaymentResult authorize(OrderId orderId, Money amount);
}

/** Service applicatif : orchestre le cas d'usage. */
public class PlaceOrderService implements PlaceOrderUseCase {

    // Le domaine DÉFINIT les interfaces (ports)
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;
    private final PricingService pricingService;

    // L'infrastructure IMPLÉMENTE via injection de dépendances
    public PlaceOrderService(
            OrderRepository orderRepository,
            PaymentGateway paymentGateway,
            PricingService pricingService) {
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
        this.pricingService = pricingService;
    }

    @Override
    public OrderConfirmation placeOrder(PlaceOrderCommand command) {
        var order = Order.create(command.customerId());
        command.lines().forEach(line ->
            order.addLine(line.product(), line.quantity())
        );

        Money total = pricingService.calculate(order);
        PaymentResult payment = paymentGateway.authorize(order.id(), total);

        if (payment.isAuthorized()) {
            OrderPlaced event = order.confirm();
            orderRepository.save(order);
            return OrderConfirmation.success(order.id(), event);
        }
        return OrderConfirmation.paymentDeclined(order.id());
    }
}

/** Driven Adapter : implémentation JPA du port OrderRepository. */
@Repository
public class JpaOrderRepository implements OrderRepository {

    private final SpringDataOrderRepository springRepo;
    private final OrderMapper mapper;

    @Override
    public void save(Order order) {
        var entity = mapper.toJpaEntity(order);
        springRepo.save(entity);
    }

    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepo.findById(id.value())
            .map(mapper::toDomainObject);
    }
}