Full-stack-skills spring-data-jpa

Provides comprehensive guidance for Spring Data JPA including repositories, entity management, query methods, and database operations. Use when the user asks about Spring Data JPA, needs to work with JPA repositories, implement data access layers, or configure JPA in Spring.

install

source · Clone the upstream repo

git clone https://github.com/partme-ai/full-stack-skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/partme-ai/full-stack-skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/spring-skills/spring-data-jpa" ~/.claude/skills/partme-ai-full-stack-skills-spring-data-jpa && rm -rf "$T"

manifest: skills/spring-skills/spring-data-jpa/SKILL.md

When to use this skill

Use this skill whenever the user wants to:

Define JPA entities with annotations (@Entity, @Id, @Column)
Create Spring Data repositories (JpaRepository, CrudRepository)
Use derived query methods, @Query with JPQL/native SQL, and Specifications
Configure data sources, Hibernate dialect, and transaction management
Handle pagination, sorting, auditing, and entity graphs

How to use this skill

Workflow

Define entities with JPA annotations and relationship mappings
Create repositories extending JpaRepository with derived or custom query methods
Configure the data source in
```
application.yml
```
or
```
application.properties
```
Use services to encapsulate business logic with proper transaction boundaries

1. Entity Definition

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

    @Column(nullable = false)
    private String name;

    @Column(unique = true, nullable = false)
    private String email;

    @CreatedDate
    private LocalDateTime createdAt;

    // Getters and setters
}

2. Repository

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String name);
    Page<User> findByNameContaining(String name, Pageable pageable);

    @Query("SELECT u FROM User u WHERE u.email = :email")
    Optional<User> findByEmailCustom(@Param("email") String email);
}

3. Service with Transactions

@Service
@Transactional
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User create(String name, String email) {
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        return userRepository.save(user);
    }

    @Transactional(readOnly = true)
    public Page<User> search(String name, Pageable pageable) {
        return userRepository.findByNameContaining(name, pageable);
    }
}

4. Configuration

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: password
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    properties:
      hibernate.format_sql: true

Best Practices

Watch for N+1 query problems; use
```
@EntityGraph
```
or
```
JOIN FETCH
```
to control fetch strategy
Use pagination (
```
Pageable
```
) and batch operations for large datasets
Separate entities from DTOs; never expose JPA entities directly in API responses
Define clear transaction boundaries; use
```
@Transactional(readOnly = true)
```
for read operations
Use Flyway or Liquibase for schema migrations instead of
```
ddl-auto: update
```
in production

Resources

Official documentation: https://spring.io/projects/spring-data-jpa
Reference guide: https://docs.spring.io/spring-data/jpa/reference/

Keywords

spring data jpa, JPA, Repository, entity, query methods, JPQL, pagination, transactions, Hibernate, Spring Boot, persistence