spring-data-jpa

name: spring-data-jpa description: "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." license: Complete terms in LICENSE.txt

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

1. Define entities with JPA annotations and relationship mappings
2. Create repositories extending JpaRepository with derived or custom query methods
3. Configure the data source in application.yml or application.properties
4. 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