Entities

public class AnemicOrder {
    private OrderStatus status;
    private List<OrderLine> lines;

    public void setStatus(OrderStatus status) {
        this.status = status;
    }

    public void setLines(List<OrderLine> lines) {
        this.lines = lines;
    }
    // ... plain getters for everything else
}

package com.example.order.domain;

import com.example.order.application.PlaceOrderCommand;
import com.example.order.domain.event.OrderApproved;
import com.example.order.domain.event.OrderCancelled;
import com.example.order.domain.event.OrderPlaced;
import com.example.order.domain.event.OrderRejected;
import com.example.shared.CustomerId;
import com.example.shared.Money;
import com.example.shared.ProductId;
import com.example.shared.event.DomainEvent;

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Currency;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

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

public record OrderLine(ProductId productId, int quantity, Money unitPrice) {
    public Money lineTotal() {
        return unitPrice.multiply(quantity);
    }
}

public enum OrderStatus {
    APPROVAL_PENDING, APPROVED, REJECTED, CANCELLED
}

/**
 * What the Order.place(PlaceOrderCommand) factory hands back to its caller: the newly
 * created aggregate plus the domain events it raised, so PlaceOrderService can save one
 * and publish the other without Order depending on any publishing mechanism itself.
 */
public record OrderCreation(Order order, List<DomainEvent> events) {
}

public class Order {

    private static final Money MINIMUM_ORDER_AMOUNT = new Money(BigDecimal.valueOf(50), Currency.getInstance("USD"));

    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderLine> lines;
    private OrderStatus status;
    private long version;

    private Order(OrderId id, CustomerId customerId, List<OrderLine> lines, OrderStatus status) {
        this.id = id;
        this.customerId = customerId;
        this.lines = new ArrayList<>(lines);
        this.status = status;
    }

    /** Creation: a brand-new order, always born APPROVAL_PENDING -- and only if its lines are valid. */
    public static OrderCreation place(PlaceOrderCommand command) {
        requireValidLines(command.lines());
        OrderId id = OrderId.generate();
        Order order = new Order(id, command.customerId(), command.lines(), OrderStatus.APPROVAL_PENDING);
        OrderPlaced event = new OrderPlaced(id, command.customerId(), List.copyOf(order.lines),
                order.totalAmount(), Instant.now());
        return new OrderCreation(order, List.of(event));
    }

    /** Reconstitution: rebuilds an order already persisted, e.g. from a JPA row -- never raises events. */
    public static Order reconstitute(OrderId id, CustomerId customerId, List<OrderLine> lines,
                                      OrderStatus status, long version) {
        Order order = new Order(id, customerId, lines, status);
        order.version = version;
        return order;
    }

    /**
     * The creation-time invariants: at least one line, and a total that meets the minimum order amount.
     * Public and static on purpose, so an adapter that has to validate before an Order exists (see
     * Listen to Yourself) runs exactly this check rather than a copy of it.
     */
    public static void requireValidLines(List<OrderLine> lines) {
        if (lines.isEmpty()) {
            throw new IllegalArgumentException("An order must have at least one line");
        }
        Money total = totalOf(lines);
        if (total.amount().compareTo(MINIMUM_ORDER_AMOUNT.amount()) < 0) {
            throw new IllegalArgumentException("Order total " + total + " is below the minimum order amount of "
                    + MINIMUM_ORDER_AMOUNT);
        }
    }

    public List<DomainEvent> approve() {
        requireStatus(OrderStatus.APPROVAL_PENDING);
        status = OrderStatus.APPROVED;
        return List.of(new OrderApproved(id, Instant.now()));
    }

    public List<DomainEvent> reject(String reason) {
        requireStatus(OrderStatus.APPROVAL_PENDING);
        status = OrderStatus.REJECTED;
        return List.of(new OrderRejected(id, reason, Instant.now()));
    }

    public List<DomainEvent> cancel() {
        if (status != OrderStatus.APPROVAL_PENDING && status != OrderStatus.APPROVED) {
            throw new IllegalStateException("Cannot cancel order " + id + " in status " + status);
        }
        status = OrderStatus.CANCELLED;
        return List.of(new OrderCancelled(id, Instant.now()));
    }

    /** The line-mutation method that enforces the minimum-order invariant -- see Aggregates. */
    public void removeLine(OrderLine line) {
        requireModifiable();
        List<OrderLine> candidate = new ArrayList<>(lines);
        if (!candidate.remove(line)) {
            throw new IllegalArgumentException("Order " + id + " does not contain line " + line);
        }
        Money remainingTotal = candidate.stream()
                .map(OrderLine::lineTotal)
                .reduce(Money::add)
                .orElse(new Money(BigDecimal.ZERO, MINIMUM_ORDER_AMOUNT.currency()));
        if (remainingTotal.amount().compareTo(MINIMUM_ORDER_AMOUNT.amount()) < 0) {
            throw new IllegalStateException("Removing " + line + " would drop order " + id
                    + " below the minimum order amount of " + MINIMUM_ORDER_AMOUNT
                    + " (remaining would be " + remainingTotal + ")");
        }
        lines.remove(line);
    }

    public Money totalAmount() {
        return totalOf(lines);
    }

    private static Money totalOf(List<OrderLine> lines) {
        return lines.stream().map(OrderLine::lineTotal).reduce(Money::add).orElseThrow();
    }

    public OrderId id() {
        return id;
    }

    public CustomerId customerId() {
        return customerId;
    }

    public List<OrderLine> lines() {
        return List.copyOf(lines);
    }

    public OrderStatus status() {
        return status;
    }

    public long version() {
        return version;
    }

    private void requireStatus(OrderStatus expected) {
        if (status != expected) {
            throw new IllegalStateException("Expected order " + id + " to be " + expected + " but was " + status);
        }
    }

    private void requireModifiable() {
        if (status != OrderStatus.APPROVAL_PENDING) {
            throw new IllegalStateException("Cannot modify lines of order " + id + " in status " + status);
        }
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Order order)) {
            return false;
        }
        return Objects.equals(id, order.id);
    }

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

package com.example.order.infrastructure;

import com.example.order.domain.OrderId;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;

import java.util.UUID;

@Converter(autoApply = true)
public class OrderIdConverter implements AttributeConverter<OrderId, UUID> {

    @Override
    public UUID convertToDatabaseColumn(OrderId orderId) {
        return orderId == null ? null : orderId.value();
    }

    @Override
    public OrderId convertToEntityAttribute(UUID uuid) {
        return uuid == null ? null : new OrderId(uuid);
    }
}

package com.example.order.domain;

import com.example.shared.CustomerId;
import com.example.shared.Money;
import com.example.shared.ProductId;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;
import java.util.Currency;
import java.util.List;
import java.util.UUID;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;

class OrderEqualityTest {

    private static final Currency USD = Currency.getInstance("USD");

    @Test
    void ordersWithTheSameIdAreEqualRegardlessOfStatus() {
        OrderId sharedId = OrderId.generate();
        CustomerId customerId = new CustomerId(UUID.randomUUID());
        List<OrderLine> lines = List.of(
                new OrderLine(new ProductId(UUID.randomUUID()), 1, new Money(BigDecimal.valueOf(75), USD)));

        Order pending = Order.reconstitute(sharedId, customerId, lines, OrderStatus.APPROVAL_PENDING, 0L);
        Order approved = Order.reconstitute(sharedId, customerId, lines, OrderStatus.APPROVED, 1L);

        assertEquals(pending, approved, "orders sharing an id must be equal even with different status");
        assertEquals(pending.hashCode(), approved.hashCode(), "equal orders must share a hash code");
    }

    @Test
    void ordersWithDifferentIdsAreNeverEqual() {
        CustomerId customerId = new CustomerId(UUID.randomUUID());
        List<OrderLine> lines = List.of(
                new OrderLine(new ProductId(UUID.randomUUID()), 1, new Money(BigDecimal.valueOf(75), USD)));

        Order first = Order.reconstitute(OrderId.generate(), customerId, lines, OrderStatus.APPROVAL_PENDING, 0L);
        Order second = Order.reconstitute(OrderId.generate(), customerId, lines, OrderStatus.APPROVAL_PENDING, 0L);

        assertNotEquals(first, second, "orders with different ids must never be equal");
    }
}