What are the main issues when working with JPA (N+1, etc.) and how to get rid of them?

Main issues when working with JPA include:

1. N+1 query problem — when loading a collection of entities, JPA executes one query for the main entity and N additional queries for related entities. This leads to significant performance degradation.

   Solutions:

   • Use JOIN FETCH in JPQL or Criteria API for eager loading of related entities.
   • Configure @EntityGraph to define the fetch graph.
   • Use batch fetching (hibernate.default_batch_fetch_size) for grouped loading of related entities.

2. LazyInitializationException — occurs when trying to access a lazily loaded entity outside of a transaction context.

   Solutions:

   • Open a session/transaction during entity operations (Open Session in View).
   • Explicitly initialize lazy collections within a transaction.

3. Caching issues — improper use of first and second level cache can lead to stale data or excessive queries.

   Solutions:

   • Configure and use second level cache (e.g., Ehcache).
   • Control cache lifetime and update strategies.

4. Entity update and merge issues — incorrect use of merge and persist methods can lead to unexpected results.

   Solutions:

   • Clearly understand the entity lifecycle.
   • Use persist for new entities and merge for detached entities.

Example of using JOIN FETCH to avoid N+1:

String jpql = "SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id";
Order order = entityManager.createQuery(jpql, Order.class)
    .setParameter("id", orderId)
    .getSingleResult();

This allows loading the order and related items in a single query.