Spring Data JPA

🔍 What Is It?

Spring Data JPA is a layer on top of JPA (Hibernate) that eliminates boilerplate repository code.

What you get for free by extending JpaRepository:

• →save(entity) — insert or update
• →findById(id) — returns Optional<T>
• →findAll() — all entities
• →findAll(Pageable) — paginated results
• →findAll(Sort) — sorted results
• →count() — total count
• →existsById(id) — existence check
• →deleteById(id) — delete by ID
• →saveAll(entities) — batch save

Query generation strategies:

1. Derived queries — method names: findByEmailAndStatus()
2. @Query — JPQL or native SQL annotation
3. Specifications — dynamic queries via Criteria API
4. QueryDSL — type-safe dynamic queries

🎯 Why Do We Need It?

Without Spring Data JPA, every repository requires:

@Repository
public class UserRepositoryImpl {
    @PersistenceContext
    private EntityManager em;

    public Optional<User> findById(Long id) {
        return Optional.ofNullable(em.find(User.class, id));
    }
    public User save(User user) {
        if (user.getId() == null) em.persist(user);
        else em.merge(user);
        return user;
    }
    // 20 more methods...
}

With Spring Data JPA:

public interface UserRepository extends JpaRepository<User, Long> {
    // That's it. save, findById, findAll, delete all generated.
}

🏗️ What Happens in Real Projects?

In enterprise Spring Boot apps, every entity has a repository interface. The team writes:

• →Derived query methods for simple filters
• →@Query for complex JPQL queries
• →Specifications for dynamic search forms
• →Custom repository implementations for very complex queries

The auto-generated CRUD handles 80% of data access; custom queries handle the rest.

⚙️ How It Works

At application startup, Spring Data scans for interfaces extending Repository. For each one, it:

1. Creates a JDK proxy implementing the interface
2. Parses method names into query ASTs (findByEmailAndStatus → WHERE email=? AND status=?)
3. Compiles @Query annotations to JPQL/SQL
4. Registers the proxy as a Spring bean

At runtime, method calls are intercepted by the proxy and delegated to Hibernate.

💻 Example

Spring Data JPA in Practice — From basic repository to complex queries.

public interface OrderRepository extends JpaRepository<Order, Long> {

    // Derived query: WHERE customer_id = ? AND status = ?
    List<Order> findByCustomerIdAndStatus(Long customerId, OrderStatus status);

    // Derived query with pagination
    Page<Order> findByCustomerId(Long customerId, Pageable pageable);

    // Derived query: WHERE created_at BETWEEN ? AND ?
    List<Order> findByCreatedAtBetween(LocalDateTime from, LocalDateTime to);

    // JPQL query
    @Query("SELECT o FROM Order o WHERE o.totalAmount > :minAmount " +
           "AND o.status = :status ORDER BY o.createdAt DESC")
    List<Order> findHighValueOrders(
        @Param("minAmount") BigDecimal minAmount,
        @Param("status") OrderStatus status
    );

    // Native SQL query
    @Query(value = "SELECT * FROM orders WHERE DATE(created_at) = CURRENT_DATE",
           nativeQuery = true)
    List<Order> findTodaysOrders();

    // Projection — only fetch needed fields
    @Query("SELECT new com.company.dto.OrderSummary(o.id, o.orderNumber, o.totalAmount) " +
           "FROM Order o WHERE o.customerId = :customerId")
    List<OrderSummary> findOrderSummariesByCustomer(@Param("customerId") Long customerId);

    // Modifying query — UPDATE or DELETE
    @Modifying
    @Transactional
    @Query("UPDATE Order o SET o.status = :status WHERE o.id = :id")
    int updateStatus(@Param("id") Long id, @Param("status") OrderStatus status);

    // Exists check
    boolean existsByOrderNumberAndCustomerId(String orderNumber, Long customerId);

    // Count
    long countByStatusAndCreatedAtAfter(OrderStatus status, LocalDateTime since);
}

🤔 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