jpa-patterns

N+1 query problems occur when fetching an entity triggers separate queries for related data. Prevent this by using fetch joins in JPQL queries, explicit @EntityGraph annotations to define eager-load plans, or query projections to load only required fields. The Skill covers these strategies to optimize query execution and reduce database round trips.

Design lean entities by excluding unnecessary fields, use proper indexing on frequently queried columns, apply lazy loading for relationships, and set sensible defaults. This Skill teaches entity design patterns that balance maintainability with query efficiency, including auditing fields and relationship configurations that avoid performance bottlenecks.

Use Spring Data's Pageable interface for offset-limit pagination, wrap repository methods with @Transactional to define query scope and isolation, and apply projections to return only needed columns. The Skill standardizes these patterns across repositories to ensure consistent, performant data access.

Fetch joins override lazy loading for specific queries, forcing immediate loading of related entities. Use them strategically in queries where you need related data to avoid N+1 problems, but rely on lazy loading as the default. The Skill covers when and how to apply each approach based on your access patterns.

Hibernate's default lazy loading and cascade settings can cause unexpected query bloat, detached-entity errors, and performance degradation if not explicitly configured. The Skill enforces explicit fetch plans and relationship boundaries to prevent these issues and make data access predictable.

Use JPA auditing annotations (@CreatedDate, @LastModifiedDate, @CreatedBy) with Spring Data's @EnableJpaAuditing to automatically capture timestamps and user information. The Skill includes auditing patterns that standardize how entities record changes across your persistence layer.