Repositories

🔍 What Is It?

The repository pattern in Spring Data provides a clean abstraction over data access.

Repository hierarchy:

• →Repository<T, ID> — marker interface
• →CrudRepository<T, ID> — basic CRUD
• →PagingAndSortingRepository<T, ID> — + pagination/sorting
• →JpaRepository<T, ID> — + JPA-specific methods (flush, batch)
• →JpaSpecificationExecutor<T> — + dynamic Specification queries

Query methods:

• →Derived: findByFirstNameAndLastName(String first, String last)
• →@Query JPQL: @Query("SELECT u FROM User u WHERE u.email = :email")
• →@Query native: @Query(value="SELECT * FROM users WHERE email=:email", nativeQuery=true)
• →Custom implementation: full control with EntityManager

Projections:

• →Interface projections: define an interface with getters for needed fields
• →DTO projections: @Query with new constructor expression
• →Dynamic projections: repository method returns <T> with type parameter

🎯 Why Do We Need It?

Repositories provide a clean boundary between business logic and data access. Services work with domain objects and call repositories. Repositories handle SQL, transactions, and ORM mapping. This separation enables:

• →Unit testing services with mock repositories
• →Swapping databases without changing services
• →Centralizing query logic in one place

🏗️ What Happens in Real Projects?

In a production app, repositories are the only place that touches the database (via JPA). Services call repositories, not EntityManager directly. This keeps the architecture clean and testable.

⚙️ How It Works

Spring Data creates JDK proxies for repository interfaces at startup. Method calls are intercepted and routed to the appropriate query strategy: derived query parser, @Query executor, or custom implementation delegate.

💻 Example

Repository Patterns — Projections, custom implementations, and auditing repositories.

// Only fetch id, name, email — not the full User entity
public interface UserSummary {
    Long getId();
    String getFirstName();
    String getLastName();
    String getEmail();

    // Computed property via SpEL
    @Value("#{target.firstName + ' ' + target.lastName}")
    String getFullName();
}

public interface UserRepository extends JpaRepository<User, Long> {

    // Returns projection instead of full entity
    List<UserSummary> findByDepartmentId(Long departmentId);

    // Dynamic projection — caller decides what to fetch
    <T> List<T> findByRole(UserRole role, Class<T> type);
}

// Usage:
List<UserSummary> summaries = userRepository.findByDepartmentId(deptId);
// SELECT id, first_name, last_name, email FROM users WHERE department_id=?
// NOT SELECT * — much faster for large entities

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits