Clean Architecture

// Entity - no framework dependencies
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;
    private OrderStatus status;

    public Money calculateTotal() {
        return items.stream()
            .map(OrderItem::subtotal)
            .reduce(Money.ZERO, Money::add);
    }

    public void confirm() {
        if (items.isEmpty()) {
            throw new EmptyOrderException("Cannot confirm empty order");
        }
        this.status = OrderStatus.CONFIRMED;
    }
}

public class PlaceOrderUseCase implements PlaceOrderInputPort {
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;
    private final PlaceOrderOutputPort outputPort;

    public PlaceOrderUseCase(OrderRepository orderRepository,
                             PaymentGateway paymentGateway,
                             PlaceOrderOutputPort outputPort) {
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
        this.outputPort = outputPort;
    }

    @Override
    public void execute(PlaceOrderRequest request) {
        Order order = orderRepository.findById(request.getOrderId());
        order.confirm();
        paymentGateway.charge(order.getCustomerId(), order.calculateTotal());
        orderRepository.save(order);
        outputPort.presentSuccess(new PlaceOrderResponse(order.getId()));
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final PlaceOrderInputPort placeOrderUseCase;

    @PostMapping
    public ResponseEntity<OrderDto> placeOrder(@RequestBody PlaceOrderDto dto) {
        PlaceOrderRequest request = new PlaceOrderRequest(dto.getOrderId());
        placeOrderUseCase.execute(request);
        return ResponseEntity.accepted().build();
    }
}

// Defined in APPLICATION layer (inner)
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

// Defined in APPLICATION layer (inner)
public interface PaymentGateway {
    PaymentResult charge(CustomerId customerId, Money amount);
}

// Implemented in ADAPTER layer (outer)
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springDataRepo;
    private final OrderMapper mapper;

    @Override
    public Order findById(OrderId id) {
        OrderJpaEntity entity = springDataRepo.findById(id.getValue())
            .orElseThrow(() -> new OrderNotFoundException(id));
        return mapper.toDomain(entity);
    }

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

// === DOMAIN LAYER ===
public record OrderId(UUID value) {}
public record CustomerId(UUID value) {}

public class Money {
    public static final Money ZERO = new Money(BigDecimal.ZERO);
    private final BigDecimal amount;

    public Money(BigDecimal amount) { this.amount = amount; }
    public Money add(Money other) { return new Money(this.amount.add(other.amount)); }
    public BigDecimal getAmount() { return amount; }
}

public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;
    private OrderStatus status;

    public Order(OrderId id, CustomerId customerId, List<OrderItem> items) {
        this.id = id;
        this.customerId = customerId;
        this.items = new ArrayList<>(items);
        this.status = OrderStatus.DRAFT;
    }

    public Money calculateTotal() {
        return items.stream()
            .map(OrderItem::subtotal)
            .reduce(Money.ZERO, Money::add);
    }

    public void confirm() {
        if (items.isEmpty()) throw new EmptyOrderException(id);
        if (status != OrderStatus.DRAFT) throw new InvalidStateException(id, status);
        this.status = OrderStatus.CONFIRMED;
    }

    // getters omitted for brevity
}

// === APPLICATION LAYER ===
public interface PlaceOrderInputPort {
    PlaceOrderResponse execute(PlaceOrderRequest request);
}

public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
}

public interface PaymentGateway {
    PaymentResult charge(CustomerId customerId, Money amount);
}

public record PlaceOrderRequest(UUID orderId) {}
public record PlaceOrderResponse(UUID orderId, String status, BigDecimal total) {}

public class PlaceOrderUseCase implements PlaceOrderInputPort {
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;

    public PlaceOrderUseCase(OrderRepository orderRepository,
                             PaymentGateway paymentGateway) {
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
    }

    @Override
    public PlaceOrderResponse execute(PlaceOrderRequest request) {
        Order order = orderRepository.findById(new OrderId(request.orderId()));
        order.confirm();

        Money total = order.calculateTotal();
        PaymentResult result = paymentGateway.charge(order.getCustomerId(), total);

        if (!result.isSuccessful()) {
            throw new PaymentFailedException(order.getId(), result.errorMessage());
        }

        orderRepository.save(order);
        return new PlaceOrderResponse(order.getId().value(), "CONFIRMED", total.getAmount());
    }
}

// === ADAPTER LAYER (Spring Controller) ===
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {
    private final PlaceOrderInputPort placeOrder;

    public OrderController(PlaceOrderInputPort placeOrder) {
        this.placeOrder = placeOrder;
    }

    @PostMapping("/{orderId}/confirm")
    public ResponseEntity<PlaceOrderResponse> confirmOrder(@PathVariable UUID orderId) {
        PlaceOrderResponse response = placeOrder.execute(new PlaceOrderRequest(orderId));
        return ResponseEntity.ok(response);
    }
}

// === INFRASTRUCTURE (Wiring) ===
@Configuration
public class BeanConfiguration {
    @Bean
    public PlaceOrderInputPort placeOrderUseCase(OrderRepository orderRepository,
                                                  PaymentGateway paymentGateway) {
        return new PlaceOrderUseCase(orderRepository, paymentGateway);
    }
}

class PlaceOrderUseCaseTest {

    private OrderRepository orderRepository;
    private PaymentGateway paymentGateway;
    private PlaceOrderUseCase useCase;

    @BeforeEach
    void setUp() {
        orderRepository = mock(OrderRepository.class);
        paymentGateway = mock(PaymentGateway.class);
        useCase = new PlaceOrderUseCase(orderRepository, paymentGateway);
    }

    @Test
    void shouldConfirmOrderAndChargePayment() {
        // Given
        Order order = new Order(
            new OrderId(UUID.randomUUID()),
            new CustomerId(UUID.randomUUID()),
            List.of(new OrderItem("Widget", new Money(new BigDecimal("29.99")), 2))
        );
        when(orderRepository.findById(any())).thenReturn(order);
        when(paymentGateway.charge(any(), any()))
            .thenReturn(PaymentResult.success());

        // When
        PlaceOrderResponse response = useCase.execute(
            new PlaceOrderRequest(order.getId().value())
        );

        // Then
        assertEquals("CONFIRMED", response.status());
        verify(orderRepository).save(order);
        verify(paymentGateway).charge(order.getCustomerId(), order.calculateTotal());
    }

    @Test
    void shouldRejectEmptyOrder() {
        // Given
        Order emptyOrder = new Order(
            new OrderId(UUID.randomUUID()),
            new CustomerId(UUID.randomUUID()),
            List.of()  // no items
        );
        when(orderRepository.findById(any())).thenReturn(emptyOrder);

        // When / Then
        assertThrows(EmptyOrderException.class, () ->
            useCase.execute(new PlaceOrderRequest(emptyOrder.getId().value()))
        );
        verify(paymentGateway, never()).charge(any(), any());
    }
}