Spring Data JPA Count the Number of Rows

This article aims to guide you through the process of how to count the number of rows in Spring Data JPA.

1. Introduction

The Java Persistence API (JPA) is a Java specification that provides a standard way to map Java objects to relational databases. It defines a set of interfaces and annotations that allow developers to interact with databases using object-oriented paradigms. JPA provides a high-level, object-relational mapping (ORM) approach, abstracting the complexities of SQL and database interactions.

Spring Data JPA is a module of the Spring Framework that simplifies the implementation of JPA-based repositories in Java applications. It builds on top of the JPA specification and adds additional functionality and convenience. Spring Data JPA eliminates the need for boilerplate code typically associated with database operations, such as CRUD (Create, Read, Update, Delete) operations, pagination, and sorting.

2. Creating the pom.xml

        <relativePath/> <!-- lookup parent from repository -->


        <!-- Other dependencies -->

Let’s go through each section and explain what it does:

  • Spring Data JPA: This dependency provides the necessary libraries for working with Spring Data JPA.
  • Database Driver: You need to include the appropriate database driver dependency based on the database you are using. In this example, I’ve used the MySQL connector as an example.
  • Spring Boot Starter Web: This dependency is required if you’re building a web application using Spring Boot and need to expose REST endpoints or handle HTTP requests.

You can add other dependencies based on your application’s requirements. Make sure to place the above <dependencies> section within the <project> element of your pom.xml file.

Remember to configure other sections in your pom.xml, such as <groupId>, <artifactId>, and <version>, according to your project’s details.

3. Entity Class

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

public class Product {
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;
    private int quantity;

    // Constructors, getters, and setters

    public Product() {

    public Product(String name, double price, int quantity) { = name;
        this.price = price;
        this.quantity = quantity;

    // Getters and Setters for all fields

    public Long getId() {
        return id;

    public void setId(Long id) { = id;

    public String getName() {
        return name;

    public void setName(String name) { = name;

    public double getPrice() {
        return price;

    public void setPrice(double price) {
        this.price = price;

    public int getQuantity() {
        return quantity;

    public void setQuantity(int quantity) {
        this.quantity = quantity;

    // Additional methods, such as toString() or custom business logic

In this example, we have an entity class named Product. It represents a product entity that can be stored in a database. The class is annotated with @Entity to indicate that it is a persistent entity.

The @Id annotation is used to mark the primary key field of the entity, and @GeneratedValue specifies the strategy for generating the primary key values. In this case, we’re using GenerationType.IDENTITY, which relies on an auto-incrementing database column to generate unique IDs.

The class has private fields for the product’s id, name, price, and quantity. The corresponding getter and setter methods are provided for accessing and modifying these fields.

The class also includes constructors for creating instances of Product. We have an empty default constructor and another constructor that accepts the name, price, and quantity parameters.

Additionally, you can add any additional methods, such as custom business logic or overrides for toString(), equals(), and hashCode(), as per your requirements.

4. Define the Repository Interface

First, you need to define a repository interface that extends the JpaRepository interface provided by Spring Data JPA. This interface will provide the necessary methods to interact with your database.

import org.springframework.stereotype.Repository;

public interface YourEntityRepository extends JpaRepository<Product, Long> {


The above code YourEntity represents the entity class corresponding to your database table.

5. Create a Service Class

Next, create a service class that will contain the business logic for counting the rows in the database table.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

public class YourEntityService {

    private final YourEntityRepository yourEntityRepository;

    public YourEntityService(YourEntityRepository yourEntityRepository) {
        this.yourEntityRepository = yourEntityRepository;

    public long countRows() {
        return yourEntityRepository.count();

In the code above, the YourEntityService class is annotated with @Service to indicate that it’s a Spring-managed service bean. The YourEntityRepository is injected into the service using constructor injection.

The countRows() method uses the count() method provided by JpaRepository to retrieve the total number of rows in the table.

6. Use the Service in your Application

Finally, you can use the YourEntityService in your application to count the rows. Here’s an example in a controller class:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

public class YourController {

    private final YourEntityService yourEntityService;

    public YourController(YourEntityService yourEntityService) {
        this.yourEntityService = yourEntityService;

    public long countRows() {
        return yourEntityService.countRows();

In the above code, the YourController class is annotated with @RestController to indicate that it’s a Spring MVC controller. The YourEntityService is injected into the controller using constructor injection.

The countRows() method in the controller invokes the corresponding method in the service class to retrieve the count of rows.

7. Custom count queries with @Query annotations

A powerful feature of Spring Data JPA is the ability to define custom queries using the @Query annotation. This annotation allows you to write your own SQL or JPQL (Java Persistence Query Language) queries and have them executed by Spring Data JPA. This flexibility extends to counting rows as well, allowing you to create custom count queries tailored to your specific needs.

To create a custom count query, follow these steps:

Define the method in your repository interface and annotate it with @Query. Specify the query string that counts the rows using the appropriate syntax.

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT COUNT(u) FROM User u")
    long countUsers();

In this example, we have a custom countUsers() method in the UserRepository interface. The @Query annotation specifies the JPQL query “SELECT COUNT(u) FROM User u”, which counts the number of User entities.

Invoke the custom count query method in your code to retrieve the row count.

long userCount = userRepository.countUsers();

By calling the countUsers() method, Spring Data JPA will execute the custom count query and return the result.

Custom count queries provide flexibility in counting rows, as you can tailor the query to your specific requirements. Here are a few examples of custom count queries that demonstrate different counting scenarios:

Counting rows based on a condition:

@Query("SELECT COUNT(u) FROM User u WHERE u.age > :age")
long countUsersAboveAge(@Param("age") int age);

This query counts the number of User entities with an age greater than the specified value.

Counting distinct values:

@Query("SELECT COUNT(DISTINCT u.category) FROM User u")
long countDistinctCategories();

This query counts the distinct categories present in the User entities.

Counting rows with multiple conditions:

@Query("SELECT COUNT(u) FROM User u WHERE u.age > :age AND u.gender = :gender")
long countUsersWithAgeAndGender(@Param("age") int age, @Param("gender") String gender);

This query counts the number of User entities that match both the age and gender conditions.

Custom count queries provide the flexibility to handle complex counting scenarios that cannot be achieved through the auto-generated queries. By leveraging the power of SQL or JPQL, you can tailor the counting process according to your application’s specific requirements.

Remember to properly parameterize your queries using the @Param annotation for method parameters, ensuring secure and dynamic query building.

8. Conclusion

In this article, we explored the process of counting the number of rows in Spring Data JPA and discovered various techniques to optimize the counting operation. We began by understanding the background of Spring Data JPA, its integration with the Java Persistence API (JPA), and its features that simplify database operations.

9. Download the Source Code

This was an example of Spring Data JPA and how to Count the Number of Rows

You can download the full source code of this example here: Spring Data JPA Count the Number of Rows

Odysseas Mourtzoukos

Mourtzoukos Odysseas is studying to become a software engineer, at Harokopio University of Athens. Along with his studies, he is getting involved with different projects on gaming development and web applications. He is looking forward to sharing his knowledge and experience with the world.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button