Anemic Domain Model — Professional¶

// Value Object — immutable, validating, behavioral.
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(currency, "currency");
        if (amount.scale() > currency.getDefaultFractionDigits()) {
            throw new IllegalArgumentException("scale exceeds currency precision");
        }
    }

    public Money add(Money other) {
        requireSameCurrency(other);
        return new Money(amount.add(other.amount), currency);
    }

    public Money multiply(BigDecimal factor) {
        return new Money(amount.multiply(factor), currency);
    }

    private void requireSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new CurrencyMismatchException(currency, other.currency);
        }
    }
}

@Entity
@Table(name = "orders")
public class Order {

    @Id
    private OrderId id;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    @ElementCollection
    @CollectionTable(name = "order_lines", joinColumns = @JoinColumn(name = "order_id"))
    private final List<OrderLine> lines = new ArrayList<>();

    @Embedded
    private Money total;

    // JPA needs a no-arg constructor; keep it protected, never public.
    protected Order() {}

    // Factory method — the only way to create a valid Order.
    public static Order place(OrderId id, CustomerId customer, List<OrderLine> initialLines) {
        if (initialLines.isEmpty()) {
            throw new IllegalArgumentException("Order requires at least one line");
        }
        Order order = new Order();
        order.id = id;
        order.status = OrderStatus.PLACED;
        order.lines.addAll(initialLines);
        order.total = computeTotal(initialLines);
        return order;
    }

    public void addLine(OrderLine line) {
        if (status != OrderStatus.PLACED) {
            throw new IllegalStateException("Cannot modify a " + status + " order");
        }
        lines.add(line);
        total = total.add(line.subtotal());
    }

    public void ship() {
        if (status != OrderStatus.PAID) {
            throw new IllegalStateException("Cannot ship unpaid order");
        }
        status = OrderStatus.SHIPPED;
    }

    public void cancel(Reason reason) {
        if (status == OrderStatus.SHIPPED) {
            throw new IllegalStateException("Cannot cancel shipped order");
        }
        status = OrderStatus.CANCELLED;
    }

    // Read-only accessors — no setters.
    public OrderId id() { return id; }
    public OrderStatus status() { return status; }
    public Money total() { return total; }
    public List<OrderLine> lines() { return Collections.unmodifiableList(lines); }

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

@AnalyzeClasses(packages = "com.example.shop.domain",
                importOptions = ImportOption.DoNotIncludeTests.class)
class DomainArchitectureTest {

    @ArchTest
    static final ArchRule no_public_setters_in_domain =
        methods()
            .that().arePublic()
            .and().haveNameMatching("set[A-Z].*")
            .should().notBeDeclaredInClassesThat()
            .resideInAPackage("..domain..")
            .because("Domain entities must mutate through behavior, not setters");

    @ArchTest
    static final ArchRule entities_have_no_public_constructors =
        constructors()
            .that().areDeclaredInClassesThat().areAnnotatedWith(Entity.class)
            .and().areDeclaredInClassesThat().resideInAPackage("..domain..")
            .should().notBePublic()
            .because("Use static factory methods to enforce invariants at creation");

    @ArchTest
    static final ArchRule value_objects_are_immutable =
        fields()
            .that().areDeclaredInClassesThat().resideInAPackage("..domain.vo..")
            .should().beFinal()
            .because("Value Objects must be immutable");

    @ArchTest
    static final ArchRule domain_does_not_depend_on_spring =
        noClasses()
            .that().resideInAPackage("..domain..")
            .should().dependOnClassesThat()
            .resideInAnyPackage("org.springframework..", "jakarta.persistence..")
            .orShould().dependOnClassesThat().resideInAPackage("..infrastructure..");
    // Note: relaxed for JPA when domain entities are persisted directly.
}

public record CreateOrderRequest(
    UUID customerId,
    List<CreateOrderLineRequest> lines) {}

public record OrderResponse(
    UUID id,
    String status,
    BigDecimal total,
    String currency,
    List<OrderLineResponse> lines) {}

@Mapper(componentModel = "spring")
public interface OrderMapper {

    @Mapping(target = "id", source = "id.value")
    @Mapping(target = "total", source = "total.amount")
    @Mapping(target = "currency", source = "total.currency.currencyCode")
    @Mapping(target = "status", expression = "java(order.status().name())")
    OrderResponse toResponse(Order order);

    OrderLineResponse toLineResponse(OrderLine line);
}

@RestController
@RequestMapping("/orders")
class OrderController {

    private final PlaceOrderUseCase useCase;
    private final OrderMapper mapper;

    @PostMapping
    public ResponseEntity<OrderResponse> place(@Valid @RequestBody CreateOrderRequest req) {
        Order order = useCase.execute(req);
        return ResponseEntity.status(201).body(mapper.toResponse(order));
    }
}

// Query-side: anemic is fine here.
public record OrderListItem(
    UUID orderId,
    String customerName,
    String status,
    BigDecimal totalAmount,
    String currency,
    LocalDateTime placedAt) {}

@Repository
class OrderQueryRepository {
    private final JdbcTemplate jdbc;

    public List<OrderListItem> findRecent(int limit) {
        return jdbc.query(
            """
            SELECT o.id, c.name, o.status, o.total_amount, o.currency, o.placed_at
            FROM orders o JOIN customers c ON c.id = o.customer_id
            ORDER BY o.placed_at DESC LIMIT ?
            """,
            (rs, i) -> new OrderListItem(
                rs.getObject("id", UUID.class),
                rs.getString("name"),
                rs.getString("status"),
                rs.getBigDecimal("total_amount"),
                rs.getString("currency"),
                rs.getTimestamp("placed_at").toLocalDateTime()),
            limit);
    }
}

@Embeddable
@Immutable
public record Address(String street, String city, String zip, String country) {
    public Address {
        Objects.requireNonNull(street);
        Objects.requireNonNull(city);
        if (zip == null || !zip.matches("\\d{5}(-\\d{4})?")) {
            throw new IllegalArgumentException("Invalid US ZIP");
        }
    }
}