spring-data-jpa

Implement Spring Data JPA persistence layers with repositories, queries, and pagination.

Updated Apr 5, 2026
One-click install
npx skills add https://github.com/rizaldiem/digital-invitation-web_V2 --skill spring-data-jpa-rizaldiem
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: spring-data-jpa
Source: https://github.com/rizaldiem/digital-invitation-web_V2/tree/main/.windsurf/skills/spring-data-jpa
Command: npx skills add https://github.com/rizaldiem/digital-invitation-web_V2 --skill spring-data-jpa-rizaldiem

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Provides clear, production-oriented patterns to implement and maintain persistence layers in Spring applications, reducing common errors like N+1 queries, inefficient pagination, and fragile transaction handling.

Core Features & Use Cases

  • Repository design: Guidance for creating repository interfaces (JpaRepository, PagingAndSortingRepository) and custom repository implementations.
  • Query strategies: Use derived methods, JPQL/@Query, native queries, projections, and @Modifying operations for updates and deletes.
  • Entity modeling & relationships: Best practices for one-to-one, one-to-many, many-to-many, bidirectional mappings, and helper methods to keep associations consistent.
  • Pagination, sorting & filtering: Pageable integration, custom criteria implementations, and efficient page-aware queries for large datasets.
  • Auditing & transactions: Configuration examples for auditing (CreatedDate, LastModifiedBy), AuditorAware, and correct transaction boundaries and propagation.
  • Performance & scaling: Advice on fetch strategies, @EntityGraph, indexes, UUID primary keys, batch operations, and multi-database setups to avoid common performance pitfalls.

Quick Start

Ask the skill to scaffold a Product entity with audit fields and a JpaRepository that supports pageable queries and an example derived and @Query method.

Frequently Asked Questions about spring-data-jpa

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I avoid N+1 queries and optimize fetch strategies in Spring Data JPA?

To avoid N+1 queries in Spring Data JPA, apply fetch strategies using @EntityGraph and optimized indexes. This pattern produces annotated entity classes that efficiently load associations, preventing performance issues during large dataset retrieval.

What is the best way to configure pagination and sorting for large datasets in Spring Data JPA?

The best way to configure pagination in Spring Data JPA is using Pageable-compatible query methods within your JpaRepository interfaces. This approach generates efficient page-aware queries, ensuring reliable sorting and filtering for large datasets.

How do I implement auditing with CreatedDate and LastModifiedBy in Spring Data JPA?

Implement Spring Data JPA auditing by applying @CreatedDate, @LastModifiedBy, and AuditorAware annotations to your entities. This configuration automatically tracks and persists creation and modification metadata across your persistence layer.

Can I use UUID primary keys and multiple datasource setups with Spring Data JPA?

Yes, Spring Data JPA supports UUID primary keys and multiple datasource setups. This Skill provides configuration patterns for both, enabling scalable multi-database architectures while maintaining robust entity mapping and transaction boundaries.

How do I write derived and @Query methods in a JpaRepository interface?

Write derived methods in a JpaRepository interface by naming methods based on property fields, or use @Query for JPQL and native SQL. This supports projections and @Modifying operations for complex updates and deletes.

When should I use @Transactional annotations for transaction boundaries in Spring Data JPA?

Use @Transactional annotations in Spring Data JPA to define correct transaction boundaries and propagation. This ensures reliable transaction handling across repository operations, preventing fragile data states during complex persistence tasks.