giuseppe-trisciuoglio/developer-kit

spring-data-jpa

Provides patterns to implement persistence layers with Spring Data JPA.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-data-jpa

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

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:

  1. Extend the appropriate repository interface:
java
   @Repository
   public interface UserRepository extends JpaRepository<User, Long> {
       // Custom methods defined here
   }
  1. Use derived queries for simple conditions:
java
   Optional<User> findByEmail(String email);
   List<User> findByStatusOrderByCreatedDateDesc(String status);
  1. Implement custom queries with `@`Query:
java
   @Query("SELECT u FROM User u WHERE u.status = :status")
   List<User> findActiveUsers(@Param("status") String status);

Configure Entities

  1. Define entities with proper annotations:
java
   @Entity
   @Table(name = "users")
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;

       @Column(nullable = false, length = 100)
       private String email;
   }
  1. Configure relationships using appropriate cascade types:
java
   @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.

  1. Set up database auditing:
java
   @CreatedDate
   @Column(nullable = false, updatable = false)
   private LocalDateTime createdDate;

Apply Query Patterns

  1. Use derived queries for simple conditions
  2. Use `@`Query for complex queries
  3. Return Optional<T> for single results
  4. Use Pageable for pagination
  5. Apply `@`Modifying for update/delete operations

Manage Transactions

  1. Mark read-only operations with `@`Transactional(readOnly = true)
  2. Use explicit transaction boundaries for modifying operations
  3. 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

java
@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

java
@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

java
@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.

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
giuseppe-trisciuoglio
커뮤니티

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

1시간 설치 수
3
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

tailwind-css-patterns

Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

dynamodb-toolbox-patterns

Provides TypeScript patterns for DynamoDB-Toolbox v2 including schema/table/entity modeling, .build() command workflow, query/scan access patterns, batch and transaction operations, and single-table design with computed keys. Use when implementing type-safe DynamoDB access layers with DynamoDB-Toolbox v2 in TypeScript services or serverless applications.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

spring-boot-dependency-injection

Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation. Use when creating services and configurations, replacing field injection, or troubleshooting ambiguous or fragile Spring wiring.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일