Domain-Driven Design (DDD)

// Anti-Corruption Layer example
// External payment API uses different model — translate at boundary
public class PaymentAntiCorruption {
    private final ExternalPaymentClient externalClient;

    public PaymentResult charge(Money amount, CustomerId customerId) {
        // Translate OUR domain model to THEIR API model
        ExternalChargeRequest request = new ExternalChargeRequest();
        request.setAmountCents(amount.toCents());
        request.setCcy(amount.getCurrency().getCode());
        request.setMerchantRef(customerId.getValue());

        ExternalChargeResponse response = externalClient.charge(request);

        // Translate THEIR response back to OUR domain model
        return new PaymentResult(
            PaymentStatus.from(response.getStatus()),
            TransactionId.of(response.getTxnId())
        );
    }
}

// Entity — identified by orderId
public class Order {
    private final OrderId id; // identity
    private OrderStatus status;
    private List<OrderLine> lines;
    private Money totalAmount;

    public void addItem(Product product, int quantity) {
        lines.add(new OrderLine(product.getId(), quantity, product.getPrice()));
        recalculateTotal();
        // Publishes domain event
    }

    @Override
    public boolean equals(Object o) {
        return o instanceof Order other && this.id.equals(other.id);
    }
}

// Value Object — defined by amount + currency
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount);
        Objects.requireNonNull(currency);
        amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency))
            throw new CurrencyMismatchException(currency, other.currency);
        return new Money(amount.add(other.amount), currency);
    }
}

// Order is the Aggregate Root
// OrderLine is an internal entity — can't be accessed directly
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private List<OrderLine> lines = new ArrayList<>();
    private OrderStatus status = OrderStatus.DRAFT;

    public void addItem(ProductId productId, int quantity, Money price) {
        if (status != OrderStatus.DRAFT) {
            throw new OrderAlreadySubmittedException(id);
        }
        if (quantity <= 0) {
            throw new InvalidQuantityException(quantity);
        }
        // Invariant enforced by aggregate root
        lines.add(new OrderLine(productId, quantity, price));
    }

    public void submit() {
        if (lines.isEmpty()) {
            throw new EmptyOrderException(id);
        }
        this.status = OrderStatus.SUBMITTED;
        DomainEvents.publish(new OrderSubmitted(id, customerId, calculateTotal()));
    }

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

public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    void save(Order order);
    void delete(OrderId id);
    List<Order> findByCustomer(CustomerId customerId);
}

// Implementation hides persistence details
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpa;
    private final OrderMapper mapper;

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

    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        jpa.save(entity);
    }
}

public record OrderSubmitted(
    OrderId orderId,
    CustomerId customerId,
    Money totalAmount,
    Instant occurredAt
) implements DomainEvent {
    public OrderSubmitted(OrderId orderId, CustomerId customerId, Money totalAmount) {
        this(orderId, customerId, totalAmount, Instant.now());
    }
}

// Publishing from aggregate
public class Order {
    private final List<DomainEvent> events = new ArrayList<>();

    public void submit() {
        this.status = OrderStatus.SUBMITTED;
        events.add(new OrderSubmitted(id, customerId, calculateTotal()));
    }

    public List<DomainEvent> getDomainEvents() {
        return Collections.unmodifiableList(events);
    }

    public void clearEvents() {
        events.clear();
    }
}

// Application service dispatches events after persistence
@Transactional
public void submitOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    order.submit();
    orderRepository.save(order);

    // Dispatch events after successful transaction
    order.getDomainEvents().forEach(eventPublisher::publish);
    order.clearEvents();
}

// Traditional: store current state
// orders table: {id: 1, status: "SHIPPED", total: 150.00}

// Event Sourcing: store events
// order_events table:
// {order_id: 1, event: "OrderCreated", data: {...}, timestamp: T1}
// {order_id: 1, event: "ItemAdded", data: {product: "Widget", qty: 2}, timestamp: T2}
// {order_id: 1, event: "OrderSubmitted", data: {...}, timestamp: T3}
// {order_id: 1, event: "PaymentReceived", data: {amount: 150}, timestamp: T4}
// {order_id: 1, event: "OrderShipped", data: {tracking: "XY123"}, timestamp: T5}

// Rebuild state by replaying events
public Order reconstitute(List<DomainEvent> events) {
    Order order = new Order();
    for (DomainEvent event : events) {
        order.apply(event); // each event mutates state
    }
    return order;
}