Code10x
Persistence contextmedium3-5 years

A service returns an `Order`, and the controller calls `order.getLines()` and gets `LazyInitializationException: could not initialize proxy - no Session`. One teammate suggests making `lines` EAGER; another says just keep `spring.jpa.open-in-view=true`. What is the exception actually telling you, and what is the right fix?

A lazy relationship is a proxy that holds a reference to the session it was created in and runs its SELECT the first time something calls it. The service's transaction ended when the method returned, so the session closed and the Order became detached; when the controller finally touched lines, the proxy tried to fetch through a closed session and failed. The exception is telling you something true: this code is reading data the transaction never decided to load. Making the relationship EAGER or keeping open-in-view both make the symptom stop and both are the wrong move. The fix is to decide inside the transaction: fetch what the caller needs in the query (a fetch join or an entity graph), or map to a DTO inside the transaction so what leaves the service is a value, not a live handle.

The lesson behind it →
PreviousAn endpoint lists 500 authors with their books and takes eleven seconds; the code has no loop over queries anywhere. A teammate fixes it with `select a from Author a join fetch a.books`, and it is fast — but two authors have vanished from the list. Explain both problems.Next An entity's `equals`/`hashCode` are generated from its `@GeneratedValue` id. A new `Tag` is added to a `HashSet`, persisted, and then `set.contains(tag)` returns `false` — even though `set.size()` is 1 and iterating returns that exact object. Why, and what should an entity's `equals`/`hashCode` be based on?
More on Persistence context
A `@Transactional` service method loads an `Author`, calls `setName(...)`, and returns. There is no `save()` anywhere, yet the log shows `update Author set name=? where id=?`. Where did that UPDATE come from, and is adding `repository.save(author)` "to be safe" a good idea?A long-running `@Transactional` job loads an `Account`, does some work, then re-runs a JPQL query for the same account "to get the latest balance" — the SQL shows in the log — and changes its `status`. Meanwhile another request committed a new balance. After the job commits, that other request's balance change is gone. Explain every step, and how `@Version` changes the outcome.