Avoid raw JOIN FETCH hardcoding in repository queries, as it forces static mapping. Instead, leverage dynamic JPA Entity Graphs via @EntityGraph. Define your targeted fetching paths programmatically at the service boundary level. #SQL

🚀Spring Boot: Use @EntityGraph to control fetch strategies and prevent N 1 queries. #SpringBoot #SoftwareEngineering

𝗛𝗼𝘄 𝘁𝗼 𝗦𝗼𝗹𝘃𝗲 𝗡 𝟭 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝟭. 𝗨𝘀𝗲 𝗙𝗘𝗧𝗖𝗛 𝗝𝗢𝗜𝗡 (𝗕𝗲𝘀𝘁 & 𝗠𝗼𝘀𝘁 𝗨𝘀𝗲𝗱) @𝘘𝘶𝘦𝘳𝘺("𝘚𝘌𝘓𝘌𝘊𝘛 𝘰 𝘍𝘙𝘖𝘔 𝘖𝘳𝘥𝘦𝘳 𝘰 𝘑𝘖𝘐𝘕 𝘍𝘌𝘛𝘊𝘏 𝘰.𝘪𝘵𝘦𝘮𝘴") 𝘓𝘪𝘴𝘵<𝘖𝘳𝘥𝘦𝘳> 𝘧𝘪𝘯𝘥𝘈𝘭𝘭𝘞𝘪𝘵𝘩𝘐𝘵𝘦𝘮𝘴(); This loads orders items in single query 𝟮. 𝗨𝘀𝗲 @𝗘𝗻𝘁𝗶𝘁𝘆𝗚𝗿𝗮𝗽𝗵 @𝘌𝘯𝘵𝘪𝘵𝘺𝘎𝘳𝘢𝘱𝘩(𝘢𝘵𝘵𝘳𝘪𝘣𝘶𝘵𝘦𝘗𝘢𝘵𝘩𝘴 = {"𝘪𝘵𝘦𝘮𝘴"}) 𝘓𝘪𝘴𝘵<𝘖𝘳𝘥𝘦𝘳> 𝘧𝘪𝘯𝘥𝘈𝘭𝘭(); 𝟯. 𝗨𝘀𝗲 𝗳𝗲𝘁𝗰𝗵 = 𝗙𝗲𝘁𝗰𝗵𝗧𝘆𝗽𝗲.𝗘𝗔𝗚𝗘𝗥 (⚠️ 𝗡𝗼𝘁 𝗥𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗲𝗱 𝗔𝗹𝘄𝗮𝘆𝘀) @OneToMany(fetch = FetchType.EAGER) Can create huge data load and memory issues 𝟰. 𝗨𝘀𝗲 𝗕𝗮𝘁𝗰𝗵 𝗙𝗲𝘁𝗰𝗵𝗶𝗻𝗴 (𝗛𝗶𝗯𝗲𝗿𝗻𝗮𝘁𝗲 𝘀𝗽𝗲𝗰𝗶𝗳𝗶𝗰) 𝘩𝘪𝘣𝘦𝘳𝘯𝘢𝘵𝘦.𝘥𝘦𝘧𝘢𝘶𝘭𝘵_𝘣𝘢𝘵𝘤𝘩_𝘧𝘦𝘵𝘤𝘩_𝘴𝘪𝘻𝘦=10 Instead of N queries, Hibernate groups them into batches 𝟱. 𝗨𝘀𝗲 𝗗𝗧𝗢 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝗶𝗼𝗻 (𝗕𝗲𝘀𝘁 𝗳𝗼𝗿 𝗔𝗣𝗜𝘀) @𝘘𝘶𝘦𝘳𝘺("𝘚𝘌𝘓𝘌𝘊𝘛 𝘯𝘦𝘸 𝘤𝘰𝘮.𝘥𝘵𝘰.𝘖𝘳𝘥𝘦𝘳𝘋𝘛𝘖(𝘰.𝘪𝘥, 𝘪.𝘯𝘢𝘮𝘦) 𝘍𝘙𝘖𝘔 𝘖𝘳𝘥𝘦𝘳 𝘰 𝘑𝘖𝘐𝘕 𝘰.𝘪𝘵𝘦𝘮𝘴 𝘪") List<OrderDTO> fetchData(); 🧠 Interview Answer (Perfect) If interviewer asks: 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗡 𝟭 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗶𝗻 𝗝𝗣𝗔? Say this: N 1 problem occurs when one query loads parent entities and additional N queries are fired to fetch child collections lazily. It leads to performance issues and is solved using fetch join, entity graph, or batch fetching.

Lazy vs Eager Loading in JPA Same relationship. Different fetch strategy. Huge performance impact. Let’s understand this with a simple restaurant example 🍽️  Imagine you ordered ONE tea. 🔴 FetchType.EAGER  You ordered one tea.   But the waiter brought tea snacks dessert together.  That’s EAGER loading. When the parent entity is fetched,   all related entities are loaded immediately —  Even if they are not required. Good for small relationships.   Risky for large collections. 🟢 FetchType.LAZY  You ordered one tea.   The waiter brought only tea.  That’s LAZY loading. Related entities are loaded only when accessed.  More controlled.   Usually better for performance. ⚠️ The N 1 Query Problem  Suppose you fetch 4 users. Query 1 → Fetch users   Query 2 → Orders for User 1   Query 3 → Orders for User 2   Query 4 → Orders for User 3   Query 5 → Orders for User 4  Total = 1 N queries  1 query loads parent entities.   N additional queries load child data.  More database round trips.   Lower performance. 🛠 How to Fix It  ✔ Use JOIN FETCH   ✔ Use @EntityGraph   ✔ Use DTO projection  Fetch associations explicitly   to avoid excessive queries. Golden Rule 🧠  EAGER loads immediately.   LAZY loads on demand.  Performance depends on *when* you fetch,   not just *what* you fetch. Interview Questions I Was Asked: Q1. Why is @ManyToOne EAGER by default?   A. Because it typically references a single small entity. Q2. What causes the N 1 problem?   A. Lazy loading inside loops without proper join fetching. Q3. Why is LAZY usually preferred?   A. It prevents unnecessary joins and reduces memory usage.

This is out of date. In JPA 3.2 you should never use untypesafe hints to pass an EntityGraph. Also, you should use the static metamodel to obtain references to named entity graphs in a completely typesafe way.

Error: LazyInitializationException: could not initialize proxy - no Session. The Hibernate session closes after findById() returns. Accessing lazy-loaded orders outside the session fails. We can use @ Transactional, JOIN FETCH, or @ EntityGraph

#JPA langsam? Nur wenn du es falsch nutzt. Julius Mischok zeigt, wie du N 1-Fallen, Lazy-Traps & Flushing-Probleme erkennst & mit @EntityGraph JPQL echten Speed rausholst. 👉 Lerne jetzt 5 konkrete Optimierungsmuster: javapro.io/de/high-speed-jpa… @hibernate @springboot #JAVAPRO

One of the most asked Java/backend interview questions in an interview ⇒The N 1 Problem in JPA → 1 initial query: To fetch N parent entities. → N subsequent queries: For each of the N parent entities, a separate query is executed to fetch its related children. → Results in 1 N database queries, causing inefficiency and slow response, performance issue Eg: Fetching 100 Authors(1 query) and then, in a loop, getting author.getBooks() for each(N=100), leads to 101 queries. ⇒How to Resolve N 1 in JPA ⇆ Goal is to fetch associated data in fewer queries, usually in a single round trip. →JPQL/HQL JOIN FETCH (Recommended for specific joins): Explicitly tells JPA to fetch associations using a JOIN in your query. Eg: @Query("SELECT a FROM Author a JOIN FETCH a.books") List<Author> findAllWithBooks(); Benefit: Single, efficient query. Caution: Can lead to Cartesian products if joining multiple collections. →Batch Fetching (@BatchSize or hibernate.default_batch_fetch_size): Instead of one query per parent, fetches associated collections for a batch of parent IDs in a single query. Eg: @BatchSize(size = 10) @OneToMany(...) private List<Book> books; Benefit: Reduces 1 N to 1 (N / batch_size) queries, avoiding Cartesian products. →Entity Graphs (@EntityGraph - Spring Data JPA / JPA 2.1 ): Declaratively defines which associations to fetch eagerly for a specific repository method. Eg: @EntityGraph(attributePaths = "books") List<Author> findAll(); Benefit: Flexible, reusable fetching strategies without explicit JPQL joins. Conclusion: Always use explicit fetching strategies (like JOIN FETCH, @BatchSize, or EntityGraph) to address N 1 issues and ensure efficient database interaction

Custom JPA Queries and Optimization with Spring Data JPA: This Java example demonstrates Spring Data JPA's advanced features for database operations. It uses @Query for a custom JPQL query to fetch users by status, @EntityGraph to optimize fetching of related entities, and @CreatedDate/@LastModifiedDate for automatic auditing of entity creation and modification timestamps. These features enhance query flexibility, performance, and maintainability in a Spring-based application.

Spring Data JPA Features: Spring Data JPA enhances database operations with @Query for custom JPQL, @EntityGraph for fetch optimization, and auditing via @CreatedDate and @LastModifiedDate. -> Executes custom JPQL to fetch users by status using @Param. -> Eagerly fetches department to optimize data retrieval. -> Auto-tracks creation/update timestamps with @CreatedDate and @LastModifiedDate. -> Simplifies custom queries, fetching, and auditing for efficient JPA usage.

2. [@EntityGraph to Fix N 1] This loads authors and their books in a single query. Bye-bye N 1! #ayshriv #java #springboot

1. [@OneToMany LAZY Load Warning] Accessing books without a fetch strategy in a loop causes N 1 problem. Fix it using JOIN FETCH or @EntityGraph.

✅ Spring Boot JPA H2 @EntityGraph #java #springboot #jpa #h2 #entitygraph

Advanced Database Tuning ✅ Databases are often the biggest bottleneck in improving API performance. Even if you have indexes set, inefficient data fetching strategies and queries can lead to bad performance. What techniques can help here? - Using a single query, we can use JPA’s @ EntityGraph or JPQL JOIN FETCH to load the related entities eagerly. We can also use DTO projections to fetch only the required fields. - Using Batching for bulk inserts and updates. This saves network trips by combining multiple SQL statements at a time. - Use Read Replicas if your use case is read-heavy.

N 1 Query Problem? Use @EntityGraph to fetch related entities efficiently instead of multiple queries. #ayshriv #java #springboot

Avoid LazyInitializationException in Spring Data JPA by using @Transactional or fetching relationships eagerly with @EntityGraph. #SpringJPA #Hibernate #ayshriv #java

Eu geralmente uso essas regras: 1- JPA é ótimo… até não ser mais: Quando o projeto cresce, você precisa ir além do básico. 2- JPQL só para queries simples. Para relatórios pesados, joins complexos ou filtros dinâmicos demais: Usar Native Queries com SQL puro. 3- Use JOIN FETCH e EntityGraph para evitar o famoso problema do N 1 em consultas 4- Transações longas são inimigas da performance. 5- Nunca usar JPA pra operações em massa. 6- Precisa só de 3 campos? Não carregue o objeto inteiro. 7- Considerar Spring Data JDBC quando: você tem domínios mais simples e um controle maior sobre o banco. Em tempo: Uma combinação de JPA procedures/functions diretas no banco pode ser mais valioso do que diversas dicas acima. Deixe o banco trabalhar por você e não o spring.

The package org.hibernate.graph was long overdue for a complete overhaul. It's now been re-engineered, which fixed a number of holes in our implementation of JPA's EntityGraph facility.

Ever aince Hibernate 2, the way to avoid cartesian products in eager fetching is SUBSELECT fetching. This is sadly not available with JPA's EntityGraph, but it is available via @FetchProfile.

London Clojurians Talk: Introducing EntityGraph: Ergonomic Data Store for SPA State (by Geo Grigoryan) youtu.be/G-KOJyoLWrg Discussions: discu.eu/q/youtu.be/G-KOJyoL… #clojure #programming