Domain-Driven Design: Modeling Complex Business Domains

// Entity — identity matters
class Order {
    private final OrderId id;       // identity
    private OrderStatus status;     // mutable state
    private Money totalAmount;

    public Order(OrderId id, Money totalAmount) {
        this.id = id;
        this.totalAmount = totalAmount;
        this.status = OrderStatus.PENDING;
    }

    // Two orders with the same ID are the same order, regardless of status
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Order)) return false;
        return this.id.equals(((Order) o).id);
    }
}

// Value Object — value matters, no identity
class Money {
    private final BigDecimal amount;
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

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

    // Equality by value
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Money)) return false;
        Money m = (Money) o;
        return this.amount.equals(m.amount) && this.currency.equals(m.currency);
    }
}

class Order {
    private final OrderId id;
    private List<OrderItem> items = new ArrayList<>();
    private OrderStatus status;

    public void addItem(ProductId productId, int quantity, Money price) {
        if (status != OrderStatus.DRAFT)
            throw new IllegalStateException("Cannot modify a confirmed order");
        items.add(new OrderItem(productId, quantity, price));
    }

    public void confirm() {
        if (items.isEmpty())
            throw new IllegalStateException("Cannot confirm an empty order");
        this.status = OrderStatus.CONFIRMED;
        // register domain event here
    }
}

// Domain event
public class OrderConfirmed {
    private final OrderId orderId;
    private final Instant occurredAt;
    private final Money totalAmount;

    public OrderConfirmed(OrderId orderId, Money totalAmount) {
        this.orderId = orderId;
        this.totalAmount = totalAmount;
        this.occurredAt = Instant.now();
    }
    // getters...
}

// Inside Order aggregate
public void confirm() {
    if (items.isEmpty()) throw new IllegalStateException("Empty order");
    this.status = OrderStatus.CONFIRMED;
    DomainEventPublisher.publish(new OrderConfirmed(this.id, this.totalAmount()));
}

// Domain layer — defines the contract
interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

// Infrastructure layer — implements the contract
class JpaOrderRepository implements OrderRepository {
    private final OrderJpaDao dao;  // Spring Data JPA

    @Override
    public Order findById(OrderId id) {
        return dao.findById(id.value())
            .map(OrderMapper::toDomain)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }

    @Override
    public void save(Order order) {
        dao.save(OrderMapper.toEntity(order));
    }
}

class LegacyEmployeeAdapter {
    private final LegacyEmployeeDao legacyDao;

    // Translate from legacy model to domain model
    public Employee findByEmployeeCode(String code) {
        LegacyEmployeeRecord record = legacyDao.findByCode(code);
        return Employee.builder()
            .id(EmployeeId.of(record.getId()))
            .name(record.getEmployeeName())
            .resigned(record.getIsResigned() == 1)
            .build();
    }

    // Translate from domain model back to legacy model on write
    public void save(Employee employee) {
        LegacyEmployeeRecord record = new LegacyEmployeeRecord();
        record.setId(employee.getId().value());
        record.setIsResigned(employee.isResigned() ? 1 : 0);
        legacyDao.save(record);
    }
}

┌────────────────────────────────┐
│     User Interface / API       │  ← HTTP handlers, gRPC services
├────────────────────────────────┤
│       Application Layer        │  ← Use cases, orchestration, no business logic
├────────────────────────────────┤
│        Domain Layer            │  ← Entities, aggregates, domain events, interfaces
├────────────────────────────────┤
│    Infrastructure Layer        │  ← DB, messaging, external API adapters
└────────────────────────────────┘