Tactical DDD Building Blocks — Deep Dive

graph TD
    subgraph Tactical Building Blocks
        E[Entity]
        VO[Value Object]
        AG[Aggregate]
        DE[Domain Event]
        DS[Domain Service]
        R[Repository]
        F[Factory]
    end

public class Order {
    private final OrderId id;  // Identity
    private OrderStatus status;
    private List<OrderLine> lines;
    private Money totalAmount;

    // Business methods, not just getters/setters
    public void addLine(Product product, int quantity) {
        // Invariant check
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("Cannot modify confirmed order");
        }
        lines.add(new OrderLine(product.getId(), quantity, product.getPrice()));
        recalculateTotal();
    }

    public void confirm() {
        if (lines.isEmpty()) {
            throw new IllegalStateException("Cannot confirm empty order");
        }
        this.status = OrderStatus.CONFIRMED;
        // Could raise OrderConfirmed event here
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Order)) return false;
        Order order = (Order) o;
        return id.equals(order.id);  // Identity-based equality
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        if (amount == null || currency == null) {
            throw new IllegalArgumentException("Amount and currency required");
        }
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
        this.amount = amount;
        this.currency = currency;
    }

    // Operations return new instances (immutability)
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add 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);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Money)) 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);
    }
}

public record OrderPlaced(
    OrderId orderId,
    CustomerId customerId,
    Money totalAmount,
    List<OrderLineSnapshot> lines,
    Instant occurredAt
) {
    public OrderPlaced {
        Objects.requireNonNull(orderId);
        Objects.requireNonNull(customerId);
        Objects.requireNonNull(totalAmount);
        Objects.requireNonNull(lines);
        if (occurredAt == null) {
            occurredAt = Instant.now();
        }
    }
}

// Raising events from an entity
public class Order {
    private final List<DomainEvent> domainEvents = new ArrayList<>();

    public void place() {
        // Business logic...
        this.status = OrderStatus.PLACED;

        // Raise event
        domainEvents.add(new OrderPlaced(
            this.id, this.customerId, this.totalAmount, 
            snapshotLines(), Instant.now()
        ));
    }

    public List<DomainEvent> getDomainEvents() {
        return List.copyOf(domainEvents);
    }

    public void clearDomainEvents() {
        domainEvents.clear();
    }
}

// Domain Service (pure domain logic)
public class PricingService {
    public Money calculateOrderTotal(Order order, CustomerTier tier) {
        Money subtotal = order.getSubtotal();
        Money discount = calculateDiscount(subtotal, tier);
        return subtotal.subtract(discount);
    }

    private Money calculateDiscount(Money amount, CustomerTier tier) {
        BigDecimal discountRate = switch (tier) {
            case BRONZE -> BigDecimal.ZERO;
            case SILVER -> new BigDecimal("0.05");
            case GOLD -> new BigDecimal("0.10");
            case PLATINUM -> new BigDecimal("0.15");
        };
        return amount.multiply(discountRate);
    }
}

// Application Service (orchestration)
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final PricingService pricingService;
    private final CustomerRepository customerRepository;

    public void placeOrder(PlaceOrderCommand command) {
        Customer customer = customerRepository.findById(command.customerId())
            .orElseThrow(() -> new CustomerNotFoundException(command.customerId()));

        Order order = Order.create(command.items());
        Money total = pricingService.calculateOrderTotal(order, customer.getTier());
        order.setTotal(total);
        order.place();

        orderRepository.save(order);
        // Publish domain events...
    }
}

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

// Adapter (implementation in infrastructure layer)
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderMapper mapper;

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

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

public class OrderFactory {
    private final ProductRepository productRepository;
    private final PricingService pricingService;

    public Order createFromCart(Cart cart, Customer customer) {
        // Validate products exist and are available
        List<OrderLine> lines = cart.getItems().stream()
            .map(item -> {
                Product product = productRepository.findById(item.productId())
                    .orElseThrow(() -> new ProductNotFoundException(item.productId()));
                if (!product.isAvailable()) {
                    throw new ProductUnavailableException(product.getId());
                }
                return new OrderLine(product.getId(), item.quantity(), product.getPrice());
            })
            .toList();

        Order order = new Order(OrderId.generate(), customer.getId(), lines);
        Money total = pricingService.calculateOrderTotal(order, customer.getTier());
        order.setTotal(total);

        return order;
    }
}