Implementing Hexagonal Architecture (Ports & Adapters) and Clean Architecture in Spring Boot

public interface CreateOrderUseCase {
    OrderResult execute(CreateOrderCommand command);
}

public interface OrderRepository {
    Order save(Order order);
    Optional<Order> findById(OrderId id);
}

package com.example.ecommerce.domain.model;

import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Core domain entity representing an Order.
 * Notice: No JPA annotations, no Spring annotations, no framework dependencies.
 * This is pure business logic.
 */
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderLine> orderLines;
    private OrderStatus status;
    private Money totalAmount;
    private final Instant createdAt;
    private Instant updatedAt;

    // Constructor: Enforce invariants at creation
    public Order(OrderId id, CustomerId customerId, List<OrderLine> orderLines) {
        if (orderLines == null || orderLines.isEmpty()) {
            throw new IllegalArgumentException("Order must contain at least one item");
        }
        
        this.id = id;
        this.customerId = customerId;
        this.orderLines = new ArrayList<>(orderLines); // Defensive copy
        this.status = OrderStatus.PENDING;
        this.createdAt = Instant.now();
        this.updatedAt = this.createdAt;
        
        this.calculateTotal();
    }

    /**
     * Business logic: Calculate total amount.
     * This belongs in the domain, not in a service layer.
     */
    private void calculateTotal() {
        this.totalAmount = orderLines.stream()
            .map(OrderLine::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }

    /**
     * Business rule: Order can only be confirmed if it's in PENDING status.
     */
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException(
                "Cannot confirm order in status: " + this.status
            );
        }
        
        this.status = OrderStatus.CONFIRMED;
        this.updatedAt = Instant.now();
    }

    /**
     * Business rule: Can only cancel pending or confirmed orders.
     */
    public void cancel(String reason) {
        if (this.status != OrderStatus.PENDING && 
            this.status != OrderStatus.CONFIRMED) {
            throw new IllegalStateException(
                "Cannot cancel order in status: " + this.status
            );
        }
        
        this.status = OrderStatus.CANCELLED;
        this.updatedAt = Instant.now();
        // In a real system, you might emit a domain event here
    }

    /**
     * Business rule: Validate that order total meets minimum.
     */
    public boolean meetsMinimumOrderValue(Money minimumValue) {
        return this.totalAmount.isGreaterThanOrEqualTo(minimumValue);
    }

    // Getters only (no setters - immutability where possible)
    public OrderId getId() { return id; }
    public CustomerId getCustomerId() { return customerId; }
    public List<OrderLine> getOrderLines() { 
        return Collections.unmodifiableList(orderLines); 
    }
    public OrderStatus getStatus() { return status; }
    public Money getTotalAmount() { return totalAmount; }
    public Instant getCreatedAt() { return createdAt; }
    public Instant getUpdatedAt() { return updatedAt; }
}

package com.example.ecommerce.domain.model;

import java.util.Objects;
import java.util.UUID;

/**
 * Value Object: OrderId
 * Immutable identifier for an Order.
 */
public class OrderId {
    private final UUID value;

    public OrderId(UUID value) {
        this.value = Objects.requireNonNull(value, "OrderId cannot be null");
    }

    public static OrderId generate() {
        return new OrderId(UUID.randomUUID());
    }

    public static OrderId of(String value) {
        return new OrderId(UUID.fromString(value));
    }

    public UUID getValue() {
        return value;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OrderId orderId = (OrderId) o;
        return value.equals(orderId.value);
    }

    @Override
    public int hashCode() {
        return Objects.hash(value);
    }

    @Override
    public String toString() {
        return value.toString();
    }
}

package com.example.ecommerce.domain.model;

import java.math.BigDecimal;
import java.util.Currency;
import java.util.Objects;

/**
 * Value Object: Money
 * Represents a monetary amount with currency.
 */
public class Money {
    public static final Money ZERO = new Money(BigDecimal.ZERO, Currency.getInstance("USD"));
    
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = Objects.requireNonNull(amount);
        this.currency = Objects.requireNonNull(currency);
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add money with different currencies");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }

    public Money multiply(int quantity) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), this.currency);
    }

    public boolean isGreaterThanOrEqualTo(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot compare money with different currencies");
        }
        return this.amount.compareTo(other.amount) >= 0;
    }

    // Getters
    public BigDecimal getAmount() { return amount; }
    public Currency getCurrency() { return currency; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.compareTo(money.amount) == 0 && 
               currency.equals(money.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

package com.example.ecommerce.domain.port.out;

import com.example.ecommerce.domain.model.Order;
import com.example.ecommerce.domain.model.OrderId;
import java.util.Optional;

/**
 * Output Port: Repository interface defined by the domain.
 * 
 * Notice: This interface uses domain types (Order, OrderId), not JPA entities.
 * The infrastructure layer will implement this using JPA, but the domain
 * doesn't know or care about that.
 */
public interface OrderRepository {
    
    /**
     * Persist an order.
     * @return the persisted order (with any generated fields populated)
     */
    Order save(Order order);
    
    /**
     * Find an order by its ID.
     * @return Optional containing the order if found
     */
    Optional<Order> findById(OrderId id);
    
    /**
     * Check if an order exists.
     */
    boolean existsById(OrderId id);
    
    /**
     * Delete an order.
     */
    void deleteById(OrderId id);
}

package com.example.ecommerce.domain.port.out;

import com.example.ecommerce.domain.model.CustomerId;
import com.example.ecommerce.domain.model.Money;

/**
 * Output Port: Payment processing interface.
 * The domain defines what it needs; the infrastructure provides the implementation.
 */
public interface PaymentGateway {
    
    /**
     * Process a payment.
     * @return PaymentResult containing transaction details
     */
    PaymentResult processPayment(CustomerId customerId, Money amount);
    
    /**
     * Refund a payment.
     */
    RefundResult refundPayment(String transactionId, Money amount);
}

package com.example.ecommerce.domain.port.out;

import com.example.ecommerce.domain.model.ProductId;

/**
 * Output Port: Inventory service interface.
 */
public interface InventoryService {
    
    /**
     * Check if sufficient inventory exists for a product.
     */
    boolean checkAvailability(ProductId productId, int quantity);
    
    /**
     * Reserve inventory for an order.
     */
    void reserveInventory(ProductId productId, int quantity);
    
    /**
     * Release reserved inventory (e.g., when order is cancelled).
     */
    void releaseInventory(ProductId productId, int quantity);
}

package com.example.ecommerce.domain.port.in;

import com.example.ecommerce.domain.model.OrderId;
import com.example.ecommerce.domain.model.CustomerId;
import com.example.ecommerce.domain.model.OrderLine;
import java.util.List;

/**
 * Input Port: Defines the "Create Order" use case.
 * 
 * This interface represents what the application offers to external actors.
 * Controllers or other adapters will call this interface.
 */
public interface CreateOrderUseCase {
    
    /**
     * Execute the create order use case.
     * 
     * @param command contains all data needed to create an order
     * @return result containing the created order details
     */
    OrderResult execute(CreateOrderCommand command);
    
    /**
     * Command object: Encapsulates input data for the use case.
     */
    record CreateOrderCommand(
        CustomerId customerId,
        List<OrderLineData> items,
        String shippingAddress
    ) {}
    
    /**
     * Data transfer structure for order line items.
     */
    record OrderLineData(
        String productId,
        int quantity
    ) {}
    
    /**
     * Result object: Encapsulates output data from the use case.
     */
    record OrderResult(
        OrderId orderId,
        String status,
        String totalAmount
    ) {}
}

package com.example.ecommerce.domain.service;

import com.example.ecommerce.domain.model.*;
import com.example.ecommerce.domain.port.in.CreateOrderUseCase;
import com.example.ecommerce.domain.port.out.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.stream.Collectors;

/**
 * Domain Service: Implements the CreateOrderUseCase.
 * 
 * This is where the orchestration of the business workflow happens.
 * Notice: Still no Spring annotations! This is pure business logic.
 */
public class OrderService implements CreateOrderUseCase {
    
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
    private static final Money MINIMUM_ORDER_VALUE = 
        new Money(new java.math.BigDecimal("10.00"), 
                  java.util.Currency.getInstance("USD"));
    
    // Dependencies are the output ports (interfaces)
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;
    private final InventoryService inventoryService;
    private final ProductCatalog productCatalog;

    // Constructor injection (frameworks like Spring can wire this)
    public OrderService(
            OrderRepository orderRepository,
            PaymentGateway paymentGateway,
            InventoryService inventoryService,
            ProductCatalog productCatalog) {
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
        this.inventoryService = inventoryService;
        this.productCatalog = productCatalog;
    }

    @Override
    public OrderResult execute(CreateOrderCommand command) {
        log.info("Creating order for customer: {}", command.customerId());
        
        // 1. Validate inventory availability
        validateInventoryAvailability(command.items());
        
        // 2. Build domain model from command data
        List<OrderLine> orderLines = buildOrderLines(command.items());
        Order order = new Order(
            OrderId.generate(),
            command.customerId(),
            orderLines
        );
        
        // 3. Apply business rule: minimum order value
        if (!order.meetsMinimumOrderValue(MINIMUM_ORDER_VALUE)) {
            throw new BusinessRuleViolationException(
                "Order total must be at least " + MINIMUM_ORDER_VALUE
            );
        }
        
        // 4. Reserve inventory
        reserveInventoryForOrder(orderLines);
        
        // 5. Process payment
        try {
            PaymentResult paymentResult = paymentGateway.processPayment(
                command.customerId(),
                order.getTotalAmount()
            );
            
            if (!paymentResult.isSuccessful()) {
                releaseInventoryForOrder(orderLines);
                throw new PaymentFailedException("Payment declined");
            }
            
        } catch (Exception e) {
            releaseInventoryForOrder(orderLines);
            throw new OrderCreationFailedException("Failed to process payment", e);
        }
        
        // 6. Confirm order
        order.confirm();
        
        // 7. Persist the order
        Order savedOrder = orderRepository.save(order);
        
        log.info("Order created successfully: {}", savedOrder.getId());
        
        // 8. Return result
        return new OrderResult(
            savedOrder.getId(),
            savedOrder.getStatus().toString(),
            savedOrder.getTotalAmount().getAmount().toString()
        );
    }

    private void validateInventoryAvailability(List<OrderLineData> items) {
        for (OrderLineData item : items) {
            ProductId productId = ProductId.of(item.productId());
            boolean available = inventoryService.checkAvailability(
                productId, 
                item.quantity()
            );
            
            if (!available) {
                throw new InsufficientInventoryException(
                    "Product " + item.productId() + " is not available"
                );
            }
        }
    }

    private List<OrderLine> buildOrderLines(List<OrderLineData> items) {
        return items.stream()
            .map(item -> {
                ProductId productId = ProductId.of(item.productId());
                Product product = productCatalog.findById(productId)
                    .orElseThrow(() -> new ProductNotFoundException(item.productId()));
                
                return new OrderLine(
                    productId,
                    product.getName(),
                    item.quantity(),
                    product.getPrice()
                );
            })
            .collect(Collectors.toList());
    }

    private void reserveInventoryForOrder(List<OrderLine> orderLines) {
        for (OrderLine line : orderLines) {
            inventoryService.reserveInventory(
                line.getProductId(),
                line.getQuantity()
            );
        }
    }

    private void releaseInventoryForOrder(List<OrderLine> orderLines) {
        for (OrderLine line : orderLines) {
            inventoryService.releaseInventory(
                line.getProductId(),
                line.getQuantity()
            );
        }
    }
}

package com.example.ecommerce.adapter.out.persistence.entity;

import jakarta.persistence.*;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * JPA Entity: Database representation of an Order.
 * 
 * This is separate from the domain model! We keep JPA concerns
 * isolated in the infrastructure layer.
 */
@Entity
@Table(name = "orders")
public class OrderEntity {
    
    @Id
    @Column(name = "id", columnDefinition = "UUID")
    private UUID id;
    
    @Column(name = "customer_id", nullable = false)
    private UUID customerId;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderLineEntity> orderLines = new ArrayList<>();
    
    @Column(name = "status", nullable = false)
    @Enumerated(EnumType.STRING)
    private OrderStatusEnum status;
    
    @Column(name = "total_amount", nullable = false, precision = 19, scale = 2)
    private BigDecimal totalAmount;
    
    @Column(name = "currency", nullable = false, length = 3)
    private String currency;
    
    @Column(name = "created_at", nullable = false)
    private Instant createdAt;
    
    @Column(name = "updated_at", nullable = false)
    private Instant updatedAt;

    // JPA requires a no-arg constructor
    protected OrderEntity() {}

    public OrderEntity(UUID id, UUID customerId, OrderStatusEnum status,
                       BigDecimal totalAmount, String currency,
                       Instant createdAt, Instant updatedAt) {
        this.id = id;
        this.customerId = customerId;
        this.status = status;
        this.totalAmount = totalAmount;
        this.currency = currency;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
    }

    public void addOrderLine(OrderLineEntity orderLine) {
        orderLines.add(orderLine);
        orderLine.setOrder(this);
    }

    // Getters and setters
    public UUID getId() { return id; }
    public void setId(UUID id) { this.id = id; }
    
    public UUID getCustomerId() { return customerId; }
    public void setCustomerId(UUID customerId) { this.customerId = customerId; }
    
    public List<OrderLineEntity> getOrderLines() { return orderLines; }
    public void setOrderLines(List<OrderLineEntity> orderLines) { 
        this.orderLines = orderLines; 
    }
    
    public OrderStatusEnum getStatus() { return status; }
    public void setStatus(OrderStatusEnum status) { this.status = status; }
    
    public BigDecimal getTotalAmount() { return totalAmount; }
    public void setTotalAmount(BigDecimal totalAmount) { 
        this.totalAmount = totalAmount; 
    }
    
    public String getCurrency() { return currency; }
    public void setCurrency(String currency) { this.currency = currency; }
    
    public Instant getCreatedAt() { return createdAt; }
    public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }
    
    public Instant getUpdatedAt() { return updatedAt; }
    public void setUpdatedAt(Instant updatedAt) { this.updatedAt = updatedAt; }
}

package com.example.ecommerce.adapter.out.persistence;

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.UUID;

/**
 * Spring Data JPA Repository interface.
 * This extends JpaRepository and provides basic CRUD operations.
 */
interface OrderJpaRepository extends JpaRepository<OrderEntity, UUID> {
    // Spring Data generates the implementation
}

package com.example.ecommerce.adapter.out.persistence;

import com.example.ecommerce.domain.model.Order;
import com.example.ecommerce.domain.model.OrderId;
import com.example.ecommerce.domain.port.out.OrderRepository;
import org.springframework.stereotype.Component;

import java.util.Optional;

/**
 * Adapter: Implements the OrderRepository port using Spring Data JPA.
 * 
 * This is where we bridge between the domain world and the persistence world.
 * We use mappers to convert between domain models and JPA entities.
 */
@Component
class OrderRepositoryAdapter implements OrderRepository {
    
    private final OrderJpaRepository jpaRepository;
    private final OrderEntityMapper mapper;

    public OrderRepositoryAdapter(OrderJpaRepository jpaRepository,
                                  OrderEntityMapper mapper) {
        this.jpaRepository = jpaRepository;
        this.mapper = mapper;
    }

    @Override
    public Order save(Order order) {
        // Convert domain model to JPA entity
        OrderEntity entity = mapper.toEntity(order);
        
        // Persist using Spring Data
        OrderEntity savedEntity = jpaRepository.save(entity);
        
        // Convert back to domain model
        return mapper.toDomain(savedEntity);
    }

    @Override
    public Optional<Order> findById(OrderId id) {
        return jpaRepository.findById(id.getValue())
            .map(mapper::toDomain);
    }

    @Override
    public boolean existsById(OrderId id) {
        return jpaRepository.existsById(id.getValue());
    }

    @Override
    public void deleteById(OrderId id) {
        jpaRepository.deleteById(id.getValue());
    }
}

package com.example.ecommerce.adapter.out.persistence;

import com.example.ecommerce.domain.model.*;
import org.springframework.stereotype.Component;

import java.util.Currency;
import java.util.stream.Collectors;

/**
 * Mapper: Converts between domain models and JPA entities.
 * 
 * In production, consider using MapStruct to auto-generate these mappers.
 */
@Component
class OrderEntityMapper {
    
    public OrderEntity toEntity(Order domain) {
        OrderEntity entity = new OrderEntity(
            domain.getId().getValue(),
            domain.getCustomerId().getValue(),
            OrderStatusEnum.valueOf(domain.getStatus().name()),
            domain.getTotalAmount().getAmount(),
            domain.getTotalAmount().getCurrency().getCurrencyCode(),
            domain.getCreatedAt(),
            domain.getUpdatedAt()
        );
        
        // Map order lines
        domain.getOrderLines().forEach(line -> {
            OrderLineEntity lineEntity = new OrderLineEntity(
                line.getProductId().getValue(),
                line.getProductName(),
                line.getQuantity(),
                line.getUnitPrice().getAmount(),
                line.getUnitPrice().getCurrency().getCurrencyCode()
            );
            entity.addOrderLine(lineEntity);
        });
        
        return entity;
    }
    
    public Order toDomain(OrderEntity entity) {
        // Reconstruct domain model from entity
        // Note: We might need to use reflection or a special constructor
        // to set final fields. This is a trade-off for domain immutability.
        
        OrderId orderId = new OrderId(entity.getId());
        CustomerId customerId = new CustomerId(entity.getCustomerId());
        
        List<OrderLine> orderLines = entity.getOrderLines().stream()
            .map(lineEntity -> new OrderLine(
                new ProductId(lineEntity.getProductId()),
                lineEntity.getProductName(),
                lineEntity.getQuantity(),
                new Money(
                    lineEntity.getUnitPrice(),
                    Currency.getInstance(lineEntity.getCurrency())
                )
            ))
            .collect(Collectors.toList());
        
        // In real code, you might use a builder pattern or a special
        // "reconstitution" constructor for the domain model
        return Order.reconstitute(
            orderId,
            customerId,
            orderLines,
            OrderStatus.valueOf(entity.getStatus().name()),
            new Money(entity.getTotalAmount(), 
                     Currency.getInstance(entity.getCurrency())),
            entity.getCreatedAt(),
            entity.getUpdatedAt()
        );
    }
}

package com.example.ecommerce.adapter.in.web;

import com.example.ecommerce.adapter.in.web.dto.CreateOrderRequest;
import com.example.ecommerce.adapter.in.web.dto.OrderResponse;
import com.example.ecommerce.domain.model.CustomerId;
import com.example.ecommerce.domain.port.in.CreateOrderUseCase;
import com.example.ecommerce.domain.port.in.CreateOrderUseCase.*;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;
import java.util.stream.Collectors;

/**
 * Web Adapter: REST Controller that triggers the CreateOrderUseCase.
 * 
 * This adapter:
 * 1. Handles HTTP concerns (request/response, status codes, etc.)
 * 2. Validates input (using Jakarta Bean Validation)
 * 3. Converts DTOs to domain commands
 * 4. Invokes the use case
 * 5. Converts domain results to response DTOs
 */
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {
    
    private final CreateOrderUseCase createOrderUseCase;

    public OrderController(CreateOrderUseCase createOrderUseCase) {
        this.createOrderUseCase = createOrderUseCase;
    }

    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        
        // Convert DTO to domain command
        CreateOrderCommand command = new CreateOrderCommand(
            new CustomerId(request.customerId()),
            request.items().stream()
                .map(item -> new OrderLineData(
                    item.productId(),
                    item.quantity()
                ))
                .collect(Collectors.toList()),
            request.shippingAddress()
        );
        
        // Execute use case
        OrderResult result = createOrderUseCase.execute(command);
        
        // Convert result to response DTO
        OrderResponse response = new OrderResponse(
            result.orderId().toString(),
            result.status(),
            result.totalAmount()
        );
        
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .body(response);
    }
}

package com.example.ecommerce.adapter.in.web.dto;

import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import java.util.List;

/**
 * DTO: Request object for creating an order.
 * 
 * This is specific to the REST API and includes validation annotations.
 * It's separate from domain models and use case commands.
 */
public record CreateOrderRequest(
    @NotNull(message = "Customer ID is required")
    String customerId,
    
    @NotEmpty(message = "Order must contain at least one item")
    @Valid
    List<OrderItemRequest> items,
    
    @NotBlank(message = "Shipping address is required")
    String shippingAddress
) {
    public record OrderItemRequest(
        @NotBlank(message = "Product ID is required")
        String productId,
        
        @Min(value = 1, message = "Quantity must be at least 1")
        int quantity
    ) {}
}

package com.example.ecommerce.adapter.in.web.dto;

/**
 * DTO: Response object for order creation.
 */
public record OrderResponse(
    String orderId,
    String status,
    String totalAmount
) {}

package com.example.ecommerce.application.config;

import com.example.ecommerce.domain.port.in.CreateOrderUseCase;
import com.example.ecommerce.domain.port.out.*;
import com.example.ecommerce.domain.service.OrderService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Spring Configuration: Wire up the dependencies.
 * 
 * This is the ONLY place where we have Spring-specific wiring.
 * The domain layer remains framework-agnostic.
 */
@Configuration
public class BeanConfiguration {
    
    /**
     * Create the OrderService bean and inject its dependencies.
     * 
     * Note: Spring will automatically find implementations of the port interfaces
     * (OrderRepository, PaymentGateway, etc.) because they're annotated with
     * @Component or @Service.
     */
    @Bean
    public CreateOrderUseCase createOrderUseCase(
            OrderRepository orderRepository,
            PaymentGateway paymentGateway,
            InventoryService inventoryService,
            ProductCatalog productCatalog) {
        
        return new OrderService(
            orderRepository,
            paymentGateway,
            inventoryService,
            productCatalog
        );
    }
}

@Mapper(componentModel = "spring")
public interface OrderEntityMapper {
    
    @Mapping(target = "id", source = "id.value")
    @Mapping(target = "customerId", source = "customerId.value")
    @Mapping(target = "status", source = "status")
    OrderEntity toEntity(Order domain);
    
    @Mapping(target = "id", expression = "java(new OrderId(entity.getId()))")
    @Mapping(target = "customerId", expression = "java(new CustomerId(entity.getCustomerId()))")
    Order toDomain(OrderEntity entity);
}

@SpringBootTest
@Transactional
class OrderServiceTest {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Test
    void testCreateOrder() {
        // Test requires:
        // - Full Spring Context (slow: 5-15 seconds startup)
        // - Test database (H2, Testcontainers)
        // - Transaction management
        // - Test data setup
        
        Order order = orderService.createOrder(...);
        assertThat(order).isNotNull();
    }
}

class OrderServiceTest {
    
    private OrderRepository orderRepository;
    private PaymentGateway paymentGateway;
    private InventoryService inventoryService;
    private ProductCatalog productCatalog;
    private OrderService orderService;
    
    @BeforeEach
    void setUp() {
        // Pure Java, no Spring
        orderRepository = mock(OrderRepository.class);
        paymentGateway = mock(PaymentGateway.class);
        inventoryService = mock(InventoryService.class);
        productCatalog = mock(ProductCatalog.class);
        
        orderService = new OrderService(
            orderRepository,
            paymentGateway,
            inventoryService,
            productCatalog
        );
    }
    
    @Test
    void shouldCreateOrder_whenInventoryAvailableAndPaymentSucceeds() {
        // Arrange
        CustomerId customerId = new CustomerId(UUID.randomUUID());
        Product product = new Product(
            ProductId.of("prod-123"),
            "Laptop",
            new Money(new BigDecimal("999.99"), Currency.getInstance("USD"))
        );
        
        when(productCatalog.findById(any())).thenReturn(Optional.of(product));
        when(inventoryService.checkAvailability(any(), anyInt())).thenReturn(true);
        when(paymentGateway.processPayment(any(), any()))
            .thenReturn(new PaymentResult(true, "txn-123"));
        when(orderRepository.save(any())).thenAnswer(inv -> inv.getArgument(0));
        
        // Act
        CreateOrderCommand command = new CreateOrderCommand(
            customerId,
            List.of(new OrderLineData("prod-123", 1)),
            "123 Main St"
        );
        
        OrderResult result = orderService.execute(command);
        
        // Assert
        assertThat(result.status()).isEqualTo("CONFIRMED");
        verify(inventoryService).reserveInventory(any(), eq(1));
        verify(paymentGateway).processPayment(eq(customerId), any());
        verify(orderRepository).save(any());
    }
    
    @Test
    void shouldReleaseInventory_whenPaymentFails() {
        // Test complex business scenarios without any infrastructure
        // Runs in milliseconds
    }
}

public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    // ... other fields
    
    // Public constructor for creating new orders
    public Order(OrderId id, CustomerId customerId, List<OrderLine> orderLines) {
        // Validation logic
        this.id = id;
        this.customerId = customerId;
        // ...
    }
    
    // Package-private "reconstitution" constructor for persistence adapter
    static Order reconstitute(OrderId id, CustomerId customerId,
                              List<OrderLine> orderLines, OrderStatus status,
                              Money totalAmount, Instant createdAt,
                              Instant updatedAt) {
        // No validation—trust that persisted data is valid
        Order order = new Order();
        order.id = id;
        order.customerId = customerId;
        order.orderLines = orderLines;
        order.status = status;
        order.totalAmount = totalAmount;
        order.createdAt = createdAt;
        order.updatedAt = updatedAt;
        return order;
    }
}

public class Order {
    public static class Builder {
        // Allows flexible reconstruction while still validating when build() is called
    }
}

@AnalyzeClasses(packages = "com.example.ecommerce")
public class ArchitectureTest {
    
    @ArchTest
    static final ArchRule domain_should_not_depend_on_infrastructure =
        noClasses()
            .that().resideInAPackage("..domain..")
            .should().dependOnClassesThat().resideInAnyPackage("..adapter..", "..application..");
    
    @ArchTest
    static final ArchRule domain_should_not_use_spring =
        noClasses()
            .that().resideInAPackage("..domain..")
            .should().dependOnClassesThat().resideInAnyPackage("org.springframework..");
    
    @ArchTest
    static final ArchRule ports_should_be_interfaces =
        classes()
            .that().resideInAPackage("..domain.port..")
            .should().beInterfaces();
}