Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot .

Get started with Spring Data JPA through the guided reference course:

>> CHECK OUT THE COURSE

1. Overview

While Spring Data JPA can abstract the creation of queries to retrieve entities from the database in specific situations, we sometimes need to customize our queries, such as when we add aggregation functions .

In this tutorial, we’ll focus on how to convert the results of those queries into an object. We’ll explore two different solutions, one involving the JPA specification and a POJO, and another using Spring Data Projection.

2. JPA Queries and the Aggregation Problem

JPA queries typically produce their results as instances of a mapped entity. However, queries with aggregation functions normally return the result as Object[] .

To understand the problem, let’s define a domain model based on the relationship between posts and comments:

@Entity
public class Post {
    private Integer id;
    private String title;
    private String content;
    @OneToMany(mappedBy = "post")
    private List comments;
    // additional properties
    // standard constructors, getters, and setters
@Entity
public class Comment {
    private Integer id;
    private Integer year;
    private boolean approved;
    private String content;
    @ManyToOne
    private Post post;
    // additional properties
    // standard constructors, getters, and setters
Our model defines that a post can have many comments, and each comment belongs to one post. Let’s use a Spring Data Repository with this model:

@Repository
public interface CommentRepository extends JpaRepository<Comment, Integer> {
    // query methods
Now let’s count the comments grouped by year:
@Query("SELECT c.year, COUNT(c.year) FROM Comment AS c GROUP BY c.year ORDER BY c.year DESC")
List<Object[]> countTotalCommentsByYear();
The result of the previous JPA query can’t be loaded into an instance of Comment because the result is a different shape. The year and COUNT specified in the query don’t match our entity object.
While we can still access the results in the general-purpose Object[] returned in the list, doing so will result in messy, error-prone code.
3. Customizing the Result With Class Constructors
The JPA specification allows us to customize results in an object-oriented fashion. Therefore, we can use a JPQL constructor expression to set the result:
@Query("SELECT new com.baeldung.aggregation.model.custom.CommentCount(c.year, COUNT(c.year)) "
  + "FROM Comment AS c GROUP BY c.year ORDER BY c.year DESC")
List<CommentCount> countTotalCommentsByYearClass();
This binds the output of the SELECT statement to a POJO. The class specified needs to have a constructor that matches the projected attributes exactly, but it’s not required to be annotated with @Entity.

We can also see that the constructor declared in the JPQL must have a fully qualified name:
package com.baeldung.aggregation.model.custom;
public class CommentCount {
    private Integer year;
    private Long total;
    public CommentCount(Integer year, Long total) {
        this.year = year;
        this.total = total;
    // getters and setters
4. Customizing the Result With Spring Data Projection
Another possible solution is to customize the result of JPA queries with Spring Data Projection. This functionality allows us to project query results with considerably less code.
4.1. Customizing the Result of JPA Queries
To use interface-based projection, we must define a Java interface composed of getter methods that match the projected attribute names. Let’s define an interface for our query result:
public interface ICommentCount {
    Integer getYearComment();
    Long getTotalComment();
Now let’s express our query with the result returned as List<ICommentCount>:
@Query("SELECT c.year AS yearComment, COUNT(c.year) AS totalComment "
  + "FROM Comment AS c GROUP BY c.year ORDER BY c.year DESC")
List<ICommentCount> countTotalCommentsByYearInterface();
To allow Spring to bind the projected values to our interface, we need to give aliases to each projected attribute with the property name found in the interface.

Spring Data will then construct the result on-the-fly, and return a proxy instance for each row of the result.
4.2. Customizing the Result of Native Queries
We can face situations where JPA queries aren’t as fast as native SQL, or can’t use specific features of our database engine. To solve this, we’ll use native queries.
One advantage of interface-based projection is that we can use it for native queries. Let’s use ICommentCount again and bind it to a SQL query:
@Query(value = "SELECT c.year AS yearComment, COUNT(c.*) AS totalComment "
  + "FROM comment AS c GROUP BY c.year ORDER BY c.year DESC", nativeQuery = true)
List<ICommentCount> countTotalCommentsByYearNative();
This works identically to JPQL queries.
5. Conclusion
In this article, we evaluated two different solutions to address mapping the results of JPA Queries with aggregation functions. First, we used the JPA standard involving a POJO class.
For the second solution, we used lightweight Spring Data projections with an interface. Spring Data projections allow us to write less code, both in Java and JPQL.
As always, the example code for this article is available over on GitHub.
Partner – Machinet – NPI EA (cat = Main Site)


The AI Assistant to boost Boost your productivity writing unit
tests - Machinet AI.
AI is all the rage these days, but for very good reason. The
highly practical coding companion, you'll get the power of
AI-assisted coding and automated unit test generation.

Machinet's Unit Test AI Agent utilizes your own project
context to create meaningful unit tests that intelligently aligns
with the behavior of the code.

And, the AI Chat crafts code and fixes errors with ease,
like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI:
>> Install Machinet
AI in your IntelliJ
Partner – DBSchema – NPI EA (tag = Spring Data JPA)


DbSchema is a super-flexible database designer, which can
take you from designing the DB with your team all the way to
safely deploying the schema.
The way it does all of that is by using a design model, a
database-independent image of the schema, which can be shared in a
team using GIT and compared or deployed on to any database.
And, of course, it can be heavily visual, allowing you to
interact with the database using diagrams, visually compose
queries, explore the data, generate random data, import data or
build HTML5 database reports.
Take a look at DBSchema

Partner – Bellsoft – NPI EA (cat = Spring)


Looking for the ideal Linux distro for running modern Spring
apps in the cloud?
Meet Alpaquita Linux: lightweight, secure, and powerful
enough to handle heavy workloads.
This distro is specifically designed for running Java
apps. It builds upon Alpine and features significant
enhancements to excel in high-density container environments while
meeting enterprise-grade security standards.
Specifically, the container image size is ~30% smaller than
standard options, and it consumes up to 30% less RAM:
Alpaquita Containers now.

Partner – Codium – NPI EA (cat = Testing)


Explore the secure, reliable, and high-performance Test
Execution Cloud built for scale. Right in your IDE:
CodiumAI. Meaningful Code Tests for Busy Devs

Basically, write code that works the way you meant it to.
Partner – Machinet – NPI EA (cat = Testing)


AI is all the rage these days, but for very good reason. The
highly practical coding companion, you'll get the power of
AI-assisted coding and automated unit test generation.

Machinet's Unit Test AI Agent utilizes your own project
context to create meaningful unit tests that intelligently aligns
with the behavior of the code.

Simplify Your Coding Journey with Machinet AI:
>> Install Machinet
AI in your IntelliJ
Course – LSD – NPI (cat=JPA)


Get started with Spring Data JPA through the reference Learn
Spring Data JPA:
>> CHECK OUT THE
COURSE
res – Persistence (eBook) (cat=Persistence)

An intro to Spring Data, JPA

and Transaction Semantics Details with JPA
Get Persistence Right with Spring
Download the E-book
Starting to test with Mockito?
Download the Guide
eBook – Video Security – NPI EA (cat=Spring Security)

Security basics for a REST API
access to the video
eBook – Persistence – NPI EA (cat=Persistence)

Download
the E-book