Full round replay — fetch types

Pass: @ManyToOne and @OneToOne. Collections — @OneToMany and @ManyToMany — default to LAZY. So loading one entity that touches nothing can still issue several queries.

Fail: Says everything defaults to lazy.

Pass: A to-one is one row, so fetching it was assumed cheap. That holds for loading a single entity and breaks immediately for a list — a hundred orders with three eager to-ones is three hundred extra queries before any code runs.

Fail: Calls it arbitrary.

Pass: Touching a lazy association after the persistence context closed. The field holds a proxy with nothing to load from — usually because the entity escaped the service layer and the view asked for something the service never fetched.

Fail: Blames Hibernate, or says the data was missing.

Pass: Fetch what the endpoint needs while the session is open — @EntityGraph or a join fetch — or return a DTO so no entity crosses the boundary. Not by making the association eager, and not by widening the transaction.

Fail: Sets EAGER, or adds @Transactional to the controller.

Pass: Keeps the persistence context open until the response is written, so lazy loads during rendering succeed. It defaults to TRUE in Spring Boot, which warns about it on startup. That is why most developers rarely see the exception.

Fail: Thinks it defaults to false, or has not heard of it.

Pass: It hides a real cost. Queries move into rendering — after the transaction commits and after most instrumentation stops — so a service can measure one query while the request issues fifty. Turn it off and fix what breaks; each break was issuing unplanned queries.

Fail: Calls it convenient with no downside, or calls it evil with no reason.

Pass: Hibernate has to know whether the related row exists to decide between a proxy and null, and it cannot know without querying. Fix it with optional = false, by owning the foreign key on that side, or with bytecode enhancement.

Fail: Assumes LAZY always works.

Pass: Jackson touches every getter, including lazy ones. With open-in-view on it works and issues a query per association; with it off it throws mid-serialisation, leaving a half-written response. A bidirectional relationship also recurses. Return a DTO.

Fail: Sees no problem, or reaches for @JsonIgnore.

Pass: LAZY on every association, fetch deliberately per query, and open-in-view off. A lazy association can be fetched by a query that needs it; an eager one cannot be skipped by a query that does not.

Fail: Says it depends, without saying on what.