Spring Data JPA: Simplifying Data Access (New Features)

Date: June 16 2024

---

Spring Data JPA continues to be a cornerstone for building data access layers in Java applications, simplifying interaction with databases by abstracting boilerplate code and providing powerful, flexible repositories.

Since its inception, Spring Data JPA has evolved significantly. In recent versions, particularly between 2022 and 2024, new features have been introduced that make data access even more developer-friendly, efficient, and expressive.

In this post, we’ll explore some of the latest features and how they can improve your productivity and application design.

---

1. What is Spring Data JPA?

Before diving into new features, a quick refresher: Spring Data JPA builds on the JPA specification by providing repository abstractions, query derivation, pagination, and more, reducing the need for writing boilerplate DAO code.

---

2. New Features Simplifying Data Access

a) Enhanced Query Derivation with @Query Enhancements

Spring Data JPA now supports dynamic projections and improved SpEL expressions in @Query, enabling more flexible query results.

Example:

public interface UserRepository extends JpaRepository<User, Long> {

    @Query("select u from User u where u.email = :#{#email.toLowerCase()}")
    Optional<User> findByEmailIgnoreCase(@Param("email") String email);

    // Dynamic projection example
    <T> List<T> findByLastName(String lastName, Class<T> type);
}

Here, the first method uses SpEL to dynamically transform the input, and the second uses dynamic projections to fetch partial data into different DTOs or interfaces without writing explicit queries.

---

b) Support for Java Records as Projections

Following Java 16+ support for records, Spring Data JPA now supports record-based projections, enabling immutable, concise DTOs.

Example:

public record UserSummary(String firstName, String lastName) {}

public interface UserRepository extends JpaRepository<User, Long> {
    List<UserSummary> findByActiveTrue();
}

This feature combines well with query derivation, allowing you to return lightweight summaries directly.

---

c) Improved Bulk Update/Delete Operations

Bulk operations now support better transaction management and entity state synchronization, reducing common pitfalls where entities go out of sync with the database after bulk updates.

You can now specify @Modifying(clearAutomatically = true) to clear the persistence context automatically after bulk updates:

@Modifying(clearAutomatically = true)
@Query("update User u set u.active = false where u.lastLogin < :cutoffDate")
int deactivateInactiveUsers(@Param("cutoffDate") LocalDate cutoffDate);

This prevents stale entity state issues in the session.

---

d) Native Query Mapping Improvements

Spring Data JPA now supports better mapping of native SQL queries to projections or DTOs using constructor expressions and interface-based projections, making it easier to optimize complex queries.

@Query(
  value = "SELECT u.first_name as firstName, u.last_name as lastName FROM users u WHERE u.active = true",
  nativeQuery = true)
List<UserNameProjection> findActiveUserNames();

public interface UserNameProjection {
    String getFirstName();
    String getLastName();
}

---

e) Pagination and Sorting Enhancements

Pagination support has been improved with support for Slice queries (which load only the next page to reduce overhead) and better sorting options, including nested property sorting.

Page<User> findByRole(String role, Pageable pageable);

Slice<User> findByRole(String role, Pageable pageable);

Slices are useful when you just want to know if a next page exists without fetching the total count.

---

3. Example: Putting It All Together

Let’s say you want to implement a repository for managing Product entities.

Entity:

@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private BigDecimal price;
    private boolean available;

    // getters/setters
}

DTO as a Record:

public record ProductInfo(String name, BigDecimal price) {}

Repository:

public interface ProductRepository extends JpaRepository<Product, Long> {

    // Fetch available products as DTOs
    List<ProductInfo> findByAvailableTrue();

    // Bulk update to mark products unavailable
    @Modifying(clearAutomatically = true)
    @Query("update Product p set p.available = false where p.price < :minPrice")
    int markProductsUnavailable(@Param("minPrice") BigDecimal minPrice);

    // Native query with projection
    @Query(value = "SELECT name, price FROM product WHERE available = true", nativeQuery = true)
    List<ProductInfo> findAvailableProductsNative();
}

---

4. Summary

Recent Spring Data JPA features help developers:

• Use Java records natively for projections.
• Write more dynamic, expressive queries with SpEL and dynamic projections.
• Safely perform bulk updates/deletes with automatic persistence context clearing.
• Improve native query mapping to projections.
• Utilize efficient pagination with slices and nested sorting.

These enhancements simplify data access, reduce boilerplate, and improve application performance.

---

5. What’s Next?

In upcoming posts, we’ll explore:

• Advanced transaction management techniques.
• Integrating Spring Data JPA with reactive programming.
• Optimizing query performance using caching and query hints.