spring-data-jpa-repo-creator

Creates Spring Data JPA repositories following best practices.

⭐32stars🔀2forks📁View on GitHub🕐Updated Jan 3, 2026

When & Why to Use This Skill

This Claude skill automates the creation of Spring Data JPA repositories for Spring Boot applications, ensuring adherence to industry best practices. It streamlines the development of the data access layer by generating clean, maintainable code that follows Domain-Driven Design (DDD) principles, utilizes JPQL for complex queries, and integrates JPA auditing for automated entity tracking.

Use Cases

  • 1. Rapid Project Scaffolding: Quickly generate boilerplate repository interfaces for new Spring Boot microservices, significantly reducing manual setup time.
  • 2. Standardizing Data Access: Enforce consistent coding standards across a team by using JPQL and meaningful method names instead of overly long Spring Data finder methods.
  • 3. Implementing JPA Auditing: Automatically set up BaseEntity structures with @CreatedDate and @LastModifiedDate to track entity lifecycle events without manual intervention.
  • 4. Domain-Driven Design (DDD) Alignment: Ensure that repositories are strictly created for aggregate roots, maintaining a clean architectural boundary in complex systems.
namespring-data-jpa-repo-creator
descriptionCreates Spring Data JPA repositories following best practices.

Spring Data JPA Repository Creator

Instructions

The following are key principles to follow while creating Spring Data JPA Repositories:

  • Make sure to create the recommended package structure for Spring Boot projects
  • Create repositories only for aggregate roots
  • Use @Query with JPQL for custom queries
  • Prefer meaningful method names over long Spring Data JPA finder methods
  • Use constructor expressions or Projections for read operations
  • Use default methods for convenience operations

Example: EventRepository

File: events/domain/EventRepository.java

interface EventRepository extends JpaRepository<EventEntity, EventId> {

    @Query("""
            SELECT e FROM EventEntity e
            WHERE e.startDatetime > :now
            ORDER BY e.startDatetime ASC
            """)
    List<EventEntity> findUpcomingEvents(@Param("now") Instant now);

    @Query("""
            SELECT e FROM EventEntity e
            WHERE e.code = :code
            """)
    Optional<EventEntity> findByCode(@Param("code") EventCode code);

    // Convenience methods using default interface methods
    default EventEntity getByCode(EventCode eventCode) {
        return this.findByCode(eventCode)
                .orElseThrow(() -> new ResourceNotFoundException("Event not found with code: " + eventCode));
    }
}

Enable JPA Auditing

Enable JPA Auditing support to automatically populate createdAt and updatedAt fields.

  • Add @CreatedDate and @LastModifiedDate annotations to your BaseEntity class.
  • Add @EntityListeners(AuditingEntityListener.class) to your BaseEntity class.
  • Create a Spring @Configuration class and add @EnableJpaAuditing annotation.
package dev.sivalabs.meetup4j.shared;

import jakarta.persistence.Column;
import jakarta.persistence.EntityListeners;
import jakarta.persistence.MappedSuperclass;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import java.time.Instant;

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseEntity {

    @Column(name = "created_at", nullable = false, updatable = false)
    @CreatedDate
    protected Instant createdAt;

    @Column(name = "updated_at", nullable = false)
    @LastModifiedDate
    protected Instant updatedAt;

    // Getters and setters
}

Enable JPA Auditing in your application configuration:

@Configuration
@EnableJpaAuditing
public class JpaConfig {
}