Why Every Java Developer Should Practice Explaining Their Model Aloud

Interviewer: Explain your data model.

Candidate: There is a users table, orders table and
products table. Orders has user_id as a foreign key.
I used @Entity and @OneToMany annotations.
Hibernate creates the tables automatically.

(The candidate described tables, not a model.)

Interviewer: Explain your data model.

Candidate: The core concept is an Order. An Order belongs
to one Customer and has one or more OrderLines.
Each OrderLine has a product reference, a quantity
and a unit price captured at the time of purchase,
so later price changes do not alter old orders.

Order is the aggregate root. Lines are only added
through Order.addLine(), which also recalculates the
total, so the total can never drift from the lines.

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    private Customer customer;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL,
               orphanRemoval = true)
    private List<OrderLine> lines = new ArrayList<>();

    public void addLine(OrderLine line) {
        lines.add(line);
        line.setOrder(this);
    }

    public void removeLine(OrderLine line) {
        lines.remove(line);
        line.setOrder(null);
    }
}

// Repository method that loads orders and their lines
// in one query instead of 1 + N queries.

public interface OrderRepository extends JpaRepository<Order, Long> {

    @Query("select distinct o from Order o " +
           "join fetch o.lines " +
           "where o.customer.id = :customerId")
    List<Order> findWithLines(@Param("customerId") Long customerId);
}

Spoken version:
"Listing orders triggered one query per order for its
lines. I added a join fetch so Hibernate loads orders
and lines together, and distinct removes the duplicate
Order rows the join produces."

@Entity
public class OrderLine {

    @Id @GeneratedValue
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    private Order order;

    private String sku;
    private int quantity;
    private BigDecimal unitPrice;

    protected OrderLine() { } // for JPA

    public OrderLine(String sku, int quantity, BigDecimal unitPrice) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("quantity must be positive");
        }
        this.sku = sku;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }

    public BigDecimal lineTotal() {
        return unitPrice.multiply(BigDecimal.valueOf(quantity));
    }
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof OrderLine other)) return false;
    return id != null && id.equals(other.id);
}

@Override
public int hashCode() {
    return getClass().hashCode();
}

Spoken version:
"Two lines are equal only if they have the same
database id. Before saving, the id is null, so new
lines are never equal to each other. hashCode is
constant per class, so the hash does not change
when the id is assigned after save, and a line
already in a HashSet can still be found."

CONCEPT MAP (10 minutes)

For each entity in your project, say aloud:

Entity: ____________
What real thing it represents: ____________
Entity or value object? ____________
Its identity is: ____________
It belongs to: ____________
It contains: ____________
One rule it must always obey: ____________

Repeat for every entity. If any line takes more
than 10 seconds, mark it for study.

MAPPING DRILL (15 minutes)

Point at each annotation and explain it aloud:

[ ] @Id and the generation strategy you chose
[ ] Every @ManyToOne: is it LAZY? Why?
[ ] Every @OneToMany: what is mappedBy pointing to?
[ ] Cascade types: which operations cascade and why
[ ] orphanRemoval: on or off, and what it changes
[ ] Any @Embedded / @Embeddable value objects

Then turn on SQL logging:
  spring.jpa.show-sql=true
Call one list endpoint and count the queries.
Explain the count aloud.

TOUGH QUESTIONS (answer each in under 45 seconds)

1. Why not just use Lombok @Data on entities?
2. What happens if you set order.lines but not line.order?
3. Why BigDecimal and not double for price?
4. Can an Order exist with zero lines? Should it?
5. Where does validation live, and why there?
6. How would you add a 'discount' concept to this model?
7. What breaks if you change FetchType to EAGER everywhere?

Record. Replay. Re-answer the two weakest.