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

Yeah... the idea has come of age, the proof will be when this scales i.e. adoption and evidence of clarity / meaning. #EntityGraph

@entitygraph is slept on. one annotation and hibernate stops firing a query per row.

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

今回の加筆で追加した主なトピック: ・Transactional の propagation 判断基準、readOnly の実効性 ・例外 vs Result型 の使い分け ・N 1 問題の解決策比較(JOIN FETCH / EntityGraph / Batch Fetch) ・H2 vs Testcontainers の判断軸 ・現場で起きた事故事例

En JPA, TOUTES les relations doivent être LAZY. ​Rappel des valeurs par défaut : ✅ @OneToMany / @ManyToMany : Lazy (bon comportement) ❌ @ManyToOne / @OneToOne : Eager (le piège classique) ​Pourquoi forcer le LAZY partout ? Une relation EAGER est chargée à chaque requête, même lorsque vous n'en avez pas besoin. Résultat : requêtes SQL superflues, surconsommation de mémoire et apparition du fameux problème N 1. La règle : @ManyToOne(fetch = FetchType.LAZY) @OneToOne(fetch = FetchType.LAZY) Chargez ensuite explicitement les données nécessaires via @EntityGraph ou JOIN FETCH. ​Principe d'architecture à retenir : Le chargement d'une relation doit être une décision explicite du code appelant, et non un comportement caché ou subi depuis l'entité.

Le problème N 1 en JPA/Hibernate : Vous chargez N entités, puis vous accédez à une relation lazy (@OneToMany, @ManyToOne). Hibernate déclenche 1 requête pour la liste, puis 1 requête par entité pour charger la relation. 100 commandes avec leurs lignes → 101 requêtes SQL au lieu d'1 seule. 3 façons de l'éviter, de la plus utilisée à la moins utilisée : → @EntityGraph sur la méthode du repository : Déclaratif, lisible, directement sur le Spring Data Repository. Solution par défaut aujourd'hui. @EntityGraph(attributePaths = "items") → JOIN FETCH en JPQL : Requête explicite qui charge la relation en un seul SELECT avec JOIN. Utile dans les requêtes custom. SELECT o FROM Order o JOIN FETCH o.items → Projection JPA : Si vous n'avez pas besoin des entités complètes, sélectionnez directement les champs utiles via un DTO ou une interface de projection. Plus performant, moins de mémoire, mais demande plus de code. Comment le détecter : → spring.jpa.show-sql=true en développement pour voir les requêtes générées → Hibernate Statistics pour compter les requêtes par transaction Règle simple : Si le nombre de requêtes dépend de la taille du résultat, c'est un problème N 1. #Java #SpringBoot #Hibernate #Performance

Every Software Engineer need to know about N 1 Query Problem Imagine you fetch 10 users… Then for EACH user, you fetch their posts. 1 query (users) 10 queries (posts) = 11 queries 😬 This is called the N 1 problem As you are making multiple database call List<User> users = userRepository.findAll(); for (User user : users) { List<Post> posts = postRepository.findByUserId(user.getId()); } Solution 1: JOIN FETCH (JPA) @Query("SELECT u FROM User u JOIN FETCH u.posts") List<User> users = userRepository.findAllWithPosts(); Fetch users posts in ONE query Solution 2: EntityGraph @EntityGraph(attributePaths = {"posts"}) List<User> findAll(); Solution 3: Batch Fetching (Hibernate) spring.jpa.properties.hibernate.default_batch_fetch_size=10 Reduces queries by batching Solution 4: Eager Loading But it can lead to extra data Pro Tip: Use JOIN FETCH for small datasets Use batching for large datasets Rule: "Never query inside a loop" #Java #Backend #SpringBoot #SystemDesign #Performance

𝗛𝗼𝘄 𝘁𝗼 𝗦𝗼𝗹𝘃𝗲 𝗡 𝟭 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝟭. 𝗨𝘀𝗲 𝗙𝗘𝗧𝗖𝗛 𝗝𝗢𝗜𝗡 (𝗕𝗲𝘀𝘁 & 𝗠𝗼𝘀𝘁 𝗨𝘀𝗲𝗱) @𝘘𝘶𝘦𝘳𝘺("𝘚𝘌𝘓𝘌𝘊𝘛 𝘰 𝘍𝘙𝘖𝘔 𝘖𝘳𝘥𝘦𝘳 𝘰 𝘑𝘖𝘐𝘕 𝘍𝘌𝘛𝘊𝘏 𝘰.𝘪𝘵𝘦𝘮𝘴") 𝘓𝘪𝘴𝘵<𝘖𝘳𝘥𝘦𝘳> 𝘧𝘪𝘯𝘥𝘈𝘭𝘭𝘞𝘪𝘵𝘩𝘐𝘵𝘦𝘮𝘴(); 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.

N 1 문제는 ORM을 사용하는 한 평생 따라다니는 숙제와 같다. 나는 이 글에서 제시하는 해결책들에 공감하면서도, 결국 개발자가 실행되는 SQL을 직접 모니터링하는 습관을 갖는 것이 가장 확실한 예방법이라고 생각한다. 추상화 수준이 높아질수록 내부 동작을 놓치기 쉽기 때문이다. 여러분은 실무에서 Fetch Join과 EntityGraph 중 어떤 방식을 더 선호하는지, 혹은 자신만의 해결 노하우가 있는지 궁금하다. medium.com/@sunil17bbmp/spri… #SpringBoot #JPA

500 Abfragen oder eine? Wer #JPA & Spring Data falsch einsetzt, landet im N 1-Desaster. Julius Mischok zeigt, wie du mit #EntityGraph JPQL JPA von Bremse zu Boost wechselst. 👉 Wenig Aufwand, viel Speed – jetzt in der #JAVAPRO: javapro.io/de/high-speed-jpa… #Hibernate #CleanCode

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.

get LazyInitializationException, for solved the problem we can use @transactional(readOnly=true) or entitygraph or join fetch

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

@EntityGraph is OP. Thanks @springframework

Java: 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.