DDD Tactical: Aggregates — Tasks¶

What? Eight progressive exercises that walk you from "design a small aggregate" to "fix a multi-aggregate transaction, add optimistic locking, and implement a snapshot strategy". Each task has clear inputs, a validation table you can run as JUnit tests, and a worked solution at the end. The exercises mirror real production scenarios drawn from Vaughn Vernon's Effective Aggregate Design examples. How? Work each task in order. Try to make every row of the validation table pass before reading the worked solution. If you get stuck, re-read the corresponding section of senior.md or professional.md first — most exercises map directly to one rule from those files.

Task 1 — Design the Order aggregate from scratch¶

Goal: Implement an Order aggregate root with LineItem children and an Address value object. External code can only obtain references to Order.

Requirements: - Constructor: Order(OrderId, CustomerId, Address). - Methods on root: addItem(ProductId, int qty, Money unitPrice), removeItem(LineItemId), changeShippingAddress(Address), place(). - Invariants: - Only DRAFT orders are mutable. - At most 50 line items. - Total never exceeds 100,000 USD. - Cannot place an empty order. - LineItem constructor and mutators must be package-private. - items() returns an unmodifiable view.

Validation table:

Task 2 — Fix a cross-aggregate transaction¶

Goal: Replace a multi-aggregate transaction with eventual consistency via a domain event.

Starting code:

@Transactional
public void placeOrder(OrderId orderId) {
    Order order = orders.findById(orderId).orElseThrow();
    Inventory inv = inventories.findByProduct(order.firstProductId()).orElseThrow();
    inv.reserve(order.firstQuantity());
    order.place();
    orders.save(order);
    inventories.save(inv);
}

Requirements: - One aggregate per transaction. - Order.place() emits OrderPlacedEvent. - A listener handles inventory reservation in its own transaction, after commit.

Validation table:

Task 3 — Add optimistic locking¶

Goal: Add @Version to Order and a retry policy to the command handler.

Requirements: - @Version long version on the Order entity. - Application service retries on OptimisticLockException up to 3 times with exponential backoff (50ms, 100ms, 200ms). - After 3 failures, the exception propagates to the caller.

Validation table:

Task 4 — ID-only reference between aggregates¶

Goal: Convert a model with @ManyToOne Customer customer on Order to an id-only reference.

Starting code:

@Entity
public class Order {
    @ManyToOne(cascade = CascadeType.PERSIST) private Customer customer;
}

Requirements: - Replace with @Embedded CustomerId customerId. - Update application code that previously called order.getCustomer().getName() to load the customer via CustomerRepository. - No cascade between Order and Customer.

Validation table:

Task 5 — Implement a snapshot for an event-sourced aggregate¶

Goal: Take an existing event-sourced Order and add a snapshot strategy. The repository should write a snapshot every 100 events.

Requirements: - Snapshot table stores aggregate_id, version, payload (JSON), created_at. - On load: read latest snapshot, then events with version > snapshot.version. - On save: if the new version crosses a multiple of 100, write a snapshot.

Validation table:

Task 6 — Compute aggregate-local invariant from a derived value¶

Goal: Add an invariant: "no more than 3 items of the same product per order". Implement it correctly.

Requirements: - The check happens at addItem time. - Counts items by ProductId. - The check is part of the would-be new state (validate before mutate).

Validation table:

Task 7 — Spot the boundary mistake¶

Goal: Given a Project aggregate that contains Task entities and also references a Team aggregate by @ManyToOne, identify which rule is broken and propose a fix.

@Entity
public class Project {
    @Id private UUID id;
    @OneToMany(cascade = ALL, orphanRemoval = true) private List<Task> tasks;
    @ManyToOne(cascade = PERSIST) private Team team;       // <-- problem
}

Requirements: - Write a short diagnosis (1-2 sentences) and identify the violated rule from specification.md. - Provide corrected code. - Explain how cross-aggregate effects (e.g., "team renamed") should propagate.

Validation table:

Task 8 — End-to-end command flow¶

Goal: Build a PlaceOrderCommandHandler that exercises every rule from senior.md.

Requirements: - Loads exactly one aggregate. - Calls one root method (Order.place()). - Saves the aggregate. - Publishes domain events after commit. - Retries on optimistic-lock conflicts up to 3 times. - Logs each retry attempt.

Validation table:

Worked solution: Task 1¶

public final class OrderId {
    private final UUID value;
    private OrderId(UUID value) { this.value = Objects.requireNonNull(value); }
    public static OrderId of(UUID value) { return new OrderId(value); }
    @Override public boolean equals(Object o) {
        return o instanceof OrderId other && other.value.equals(this.value);
    }
    @Override public int hashCode() { return value.hashCode(); }
}

public final class LineItemId {
    private final UUID value;
    public static LineItemId newId() { return new LineItemId(UUID.randomUUID()); }
    private LineItemId(UUID value) { this.value = value; }
}

public final class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<LineItem> items = new ArrayList<>();
    private Address shippingAddress;
    private OrderStatus status;
    private Money total;

    private static final int MAX_ITEMS = 50;
    private static final Money MAX_TOTAL = Money.of("USD", 100_000);

    public Order(OrderId id, CustomerId customerId, Address shippingAddress) {
        this.id = id;
        this.customerId = customerId;
        this.shippingAddress = shippingAddress;
        this.status = OrderStatus.DRAFT;
        this.total = Money.zero(Currency.USD);
    }

    public void addItem(ProductId pid, int qty, Money unitPrice) {
        requireDraft();
        if (items.size() >= MAX_ITEMS)
            throw new DomainException("max " + MAX_ITEMS + " items");
        var item = new LineItem(LineItemId.newId(), pid, qty, unitPrice);
        var next = total.add(item.subtotal());
        if (next.greaterThan(MAX_TOTAL))
            throw new DomainException("Total exceeds " + MAX_TOTAL);
        items.add(item);
        total = next;
    }

    public void place() {
        requireDraft();
        if (items.isEmpty()) throw new DomainException("Cannot place empty order");
        this.status = OrderStatus.PLACED;
    }

    public List<LineItem> items() { return Collections.unmodifiableList(items); }

    private void requireDraft() {
        if (status != OrderStatus.DRAFT)
            throw new DomainException("Order is not DRAFT");
    }
}

public final class LineItem {
    private final LineItemId id;
    private final ProductId productId;
    private int quantity;
    private final Money unitPrice;

    LineItem(LineItemId id, ProductId productId, int quantity, Money unitPrice) {
        this.id = id;
        this.productId = productId;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }
    Money subtotal() { return unitPrice.multiply(quantity); }
}

Note the package-private LineItem constructor and subtotal(). External code cannot construct or read a line item except through the root.

What's next¶

• interview.md — how interviewers test these same skills.
• find-bug.md — bug scenarios that exercise the same muscles.
• optimize.md — performance angles on these exercises.