Finding maximum values in your Spring Data JPA applications helps you extract critical insights from your data.

When you’re building applications that need to track highest scores, latest timestamps, or maximum transaction amounts, you’ll often need to retrieve the maximum value from your database tables.

In this tutorial, you’ll learn different approaches to find maximum values using Spring Data JPA, from simple query methods to complex JPQL queries.

Setting Up the Environment

To set up an application to use spring data JPA, you need to have below dependencies for Maven or Gradle

// MAVEN
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>3.3.5</version>
</dependency>

// GRADLE
implementation 'org.springframework.data:spring-data-jpa:3.3.5'

Entity Class

Below is the entity class that we will be referring in the examples that follow.

@Entity
@Table(name = "products")
public class Product { 
  @Id 
  @GeneratedValue(strategy = GenerationType.IDENTITY) 
  private Long id; 
  private String name; 
  private Double price; 
  // getters and setters 
}

1. Using JPQL

JPQL, an acronym for Jakarta Persistence Query Language is a platform independent query language that is used on objects or entities.

It is similar to native SQL query but instead of table and column names, it uses entity and its field names respectively.

In Spring Data JPA, you can use JPQL with @Query annotation as shown below

public interface ProductRepository extends JpaRepository<Product, Long> {
  @Query("SELECT MAX(p.price) FROM Product p WHERE p.category = :category")
  public Optional<Double> getMaxPrice(String category);
}

In above example, the query inside @Query is written in JPQL, which fetches max price of a product in a particular category.

Notice that it uses entity name after FROM and field name after WHERE and in MAX function.

2. Using native query

The power of native SQL queries lies in their ability to utilize database-specific features for finding maximum values. Example,

public interface ProductRepository extends JpaRepository<Product, Long> { 
  @Query(value = "SELECT MAX(price) FROM products", nativeQuery = true) 
  BigDecimal findMaxPriceNative(); 
}

Plus, native SQL queries give you direct access to database-specific optimizations and functions that might not be available through JPQL, allowing you to fine-tune your maximum value queries for better performance.

Note that in native query, we use database table name instead of entity name and column names instead of entity fields.

3. Derived Query

One of the most straightforward ways to find maximum values is through Spring Data JPA’s derived query methods.

You can create methods like findFirstByOrderByPriceDesc() in your repository interface, and Spring will automatically generate the appropriate query.

Here’s an example

public interface ProductRepository extends JpaRepository<Product, Long> { 
  Product findFirstByOrderByPriceDesc(); 
}

4. Pagination

Even with large datasets, you can easily implement pagination using Spring Data JPA’s Pageable interface.

Here’s how you can find the maximum price using pagination:

public Double findMaxPriceWithPagination(Pageable pageable) { 
  Page productPage = productRepository.
                      findAll(PageRequest.
                              of(0, 10, Sort.by("price").descending())); 
  return productPage.getContent().get(0).getPrice(); 
}

Performance Optimization

Even though all methods can fetch the maximum value, you need to choose the right approach based on your data volume and query complexity.

When working with large datasets (over 100,000 records), you’ll find that using native SQL queries with proper indexing can be up to 30% faster than JPQL queries.

If you’re dealing with simple max value retrieval, the findTop1OrderByFieldDesc() method provides a clean and efficient solution, while @Query with JPQL gives you more flexibility for complex scenarios.

Summing up

With this in mind, you can effectively implement maximum value retrieval in your Spring Data JPA applications using several approaches.

You’ll find that @Query annotations offer direct SQL control, while derived method names provide a more Spring-native solution.

Choose the method that best fits your application’s needs, considering both readability and performance requirements.

Finding the Max Value in Spring Data JPA