spring-data-jpa

Q: How do I install spring-data-jpa?

Run npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-data-jpa in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/spring-data-jpa/ (personal) or .claude/skills/spring-data-jpa/ (project).

by giuseppe-trisciuoglioBackend & APIs

Provides patterns to implement persistence layers with Spring Data JPA. Use when creating repositories, configuring entity relationships, writing queries (derived and @Query), setting up pagination, database auditing, transactions, UUID primary keys, multiple databases, and database indexing.

Installs: 4.1K
Last 24h: —
Trending rank: —
Security: Warn

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-data-jpa

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads spring-data-jpa automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·The skill is safe. It contains reference documentation and standard code examples for configuring and optimizing Spring Data JPA persistence layers without any security or malicious risks.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

Runlayer WarnMEDIUM ·3/3 files flagged

ZeroLeaks PassNONE ·Score: 93/100 · 2 sections analyzed

SKILL.md

The instructions your agent reads when the skill is triggered.

Spring Data JPA

Overview

Provides patterns for Spring Data JPA repositories, entity relationships, queries, pagination, auditing, and transactions.

When to Use

Creating repositories with CRUD operations, entity relationships, @Query annotations, pagination, auditing, or UUID primary keys.

Instructions

Create Repository Interfaces

To implement a repository interface:

Extend the appropriate repository interface:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Custom methods defined here
}

Use derived queries for simple conditions:

Optional<User> findByEmail(String email);
List<User> findByStatusOrderByCreatedDateDesc(String status);

Implement custom queries with @Query:

@Query("SELECT u FROM User u WHERE u.status = :status")
List<User> findActiveUsers(@Param("status") String status);

Configure Entities

Define entities with proper annotations:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String email;
}

Configure relationships using appropriate cascade types:
```
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders = new ArrayList<>();
```
Validation: Test cascade behavior with a small dataset before applying to production data. Verify delete operations don't cascade unexpectedly.

Set up database auditing:

@CreatedDate
@Column(nullable = false, updatable = false)
private LocalDateTime createdDate;

Apply Query Patterns

Use derived queries for simple conditions
Use @Query for complex queries
Return Optional<T> for single results
Use Pageable for pagination
Apply @Modifying for update/delete operations

Manage Transactions

Mark read-only operations with @Transactional(readOnly = true)
Use explicit transaction boundaries for modifying operations
Specify rollback conditions when needed

Validate and Optimize

1. Verify entity configuration:

Test cascade behavior in a transaction before production deployment
Validate bidirectional relationships sync correctly

2. Optimize query performance:

Run EXPLAIN ANALYZE on queries against large tables
If performance issues detected: add indexes → verify with EXPLAIN → repeat
Use @EntityGraph to prevent N+1 queries

3. Validate pagination:

Ensure indexed columns support pagination queries
Test with large datasets to verify cursor stability

Examples

Basic CRUD Repository

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Derived query
    List<Product> findByCategory(String category);

    // Custom query
    @Query("SELECT p FROM Product p WHERE p.price > :minPrice")
    List<Product> findExpensiveProducts(@Param("minPrice") BigDecimal minPrice);
}

Pagination Implementation

@Service
public class ProductService {
    private final ProductRepository repository;

    public Page<Product> getProducts(int page, int size) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("name").ascending());
        return repository.findAll(pageable);
    }
}

Entity with Auditing

@Entity
@EntityListeners(AuditingEntityListener.class)
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @CreatedDate
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime lastModifiedDate;

    @CreatedBy
    @Column(nullable = false, updatable = false)
    private String createdBy;
}

Best Practices

Entity Design

Use constructor injection exclusively (never field injection)
Prefer immutable fields with final modifiers
Use Java records (16+) or @Value for DTOs
Always provide proper @Id and @GeneratedValue annotations
Use explicit @Table and @Column annotations

Performance Optimization

Use appropriate fetch strategies (LAZY vs EAGER)
Implement pagination for large datasets
Use database indexes for frequently queried fields
Consider using @EntityGraph to avoid N+1 query problems

Reference Documentation

For comprehensive examples, detailed patterns, and advanced configurations, see:

Examples - Complete code examples for common scenarios
Reference - Detailed patterns and advanced configurations

Constraints and Warnings

Never expose JPA entities directly in REST APIs; always use DTOs to prevent lazy loading issues.
Avoid N+1 query problems by using @EntityGraph or JOIN FETCH in queries.
Be cautious with CascadeType.REMOVE on large collections as it can cause performance issues.
Do not use EAGER fetch type for collections; it can cause excessive database queries.
Avoid long-running transactions as they can cause database lock contention.
Use @Transactional(readOnly = true) for read operations to enable optimizations.
Be aware of the first-level cache; entities may not reflect database changes within the same transaction.
UUID primary keys can cause index fragmentation; consider using sequential UUIDs or Long IDs.
Pagination on large datasets requires proper indexing to avoid full table scans.

FAQ

What does the spring-data-jpa skill do?

How do I install spring-data-jpa?

Run npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-data-jpa in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/spring-data-jpa/ (personal) or .claude/skills/spring-data-jpa/ (project).

Which AI agents can use spring-data-jpa?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is spring-data-jpa safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed; Runlayer flagged items to review; ZeroLeaks passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains spring-data-jpa?

It is published by giuseppe-trisciuoglio in giuseppe-trisciuoglio/developer-kit. It has 4,103 recorded installs.