Spring Data JPA Projection

Spring Data JPA has become a cornerstone for Java developers, simplifying the way data is accessed and managed in relational databases. One of its powerful features is projection, which allows developers to shape query results according to their needs. In this blog post, we will dive into the world of Spring Data JPA projection, exploring what it is, why it is beneficial, and how to leverage different way of projection effectively.

Understanding Spring Data JPA Projection

Projection in Spring Data JPA refer to the ability to retrieve only a subset of data from an entity. Instead of fetching the entire entity, we can choose specific fields or even create custom projection to get exactly what we need. This optimization can significantly enhance performance, especially when dealing with large datasets.

Types of Projection

Spring Data JPA supports two main types of projections:

• Interface-based projections and
• Class-based projections.

Interface-based projections involve creating interfaces with getter methods, while class-based projections use classes with constructors to map the desired fields. Understanding the distinctions between these two approaches is crucial for choosing the right projection type for our use case.

Custom Projection

While Spring Data JPA provides default projections based on interfaces or classes, there are scenarios where we may need a more customized solution. Custom projections allow us to define precisely how the data should be projected by using SpEL (Spring Expression Language) or custom query methods. We’ll explore examples and best practices for creating custom projections that suit our specific requirements.

Performance Benefits

One of the primary motivations for using projections is the performance boost they provide. By fetching only the necessary data, we reduce the amount of data transferred between the database and the application. This not only leads to faster query execution but also minimizes the risk of over-fetching data, especially in scenarios where a subset of fields is sufficient.

Interface-based Projection

Interface-based projection involve creating an interface with getter methods that match the fields we want to project. Spring Data JPA will automatically generate a proxy implementation of the interface.

public interface BookProjection {
    String getTitle();
    String getAuthor();
}

public interface BookRepository extends JpaRepository<Book, Long> {
    List<BookProjection> findByGenre(String genre);
}

This approach is concise and clean, making it a popular choice for simple projections.

The Book entity might have many fields or columns but we can fetch only title and author with the projection.

Class-based Projection

Class-based projections use classes with constructors to map the desired fields. This approach provides more flexibility, allowing us to perform custom logic in the constructor.

public class BookProjection {
    private String title;
    private String author;

    public BookProjection(String title, String author) {
        this.title = title;
        this.author = author;
    }

    // getters
}

public interface BookRepository extends JpaRepository<Book, Long> {
    @Query("select new mypackage.BookProjection(b.title, b.author) from Book b where b.genre =:genre")
    List<BookProjection> findByGenre(String genre);
}

Dynamic Projection

Spring Data JPA supports dynamic projections also. This allows us to create projections on-the-fly based on the method signature.

public interface BookRepository extends JpaRepository<Book, Long> {
    <T> List<T> findByGenre(String genre, Class<T> type);
}

Dynamic projections are powerful when the projection structure is not known at compile time. And instead of creating multiple methods in interface to meet different kind of projection we can use only one method like shown in an example above.

Spring Data JPA Projection Native Query

In this section, let’s see the example of Spring data JPA projection Native query.

In the repository, use @Query with a native SQL query and specify BookProjection as the return type.

Assuming we have a Book entity with title and author fields, the repository will look like this:

Example:

@Query(value = "SELECT b.title AS title, b.author AS author FROM books b WHERE b.genre = :genre", nativeQuery = true)
    List<BookProjection> findByGenre(@Param("genre") String genre);

Spring Data JPA Projection Nested List

In Spring Data JPA, we can also define projections with nested lists to fetch related entities.

To illustrate, let’s say we have Book entities, each with a list of Chapter entities. We want to create a projection that includes each book’s title and author, along with the titles of all its chapters.

Step 1: Define Entity Classes

Following is a simple setup for the Book and Chapter entities with a one-to-many relationship.

package com.codersathi.springdatajpaprojection;

import jakarta.persistence.*;

import java.util.List;

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

	private String title;
	private String author;
	private String genre;

	@OneToMany(mappedBy = "book", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	private List<Chapter> chapters;

	//Getters and Setters
}

package com.codersathi.springdatajpaprojection;

import jakarta.persistence.*;

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

	private String name;

	@ManyToOne
	@JoinColumn(name = "book_id")
	private Book book;

	//Getters and Setters
}

Step 2: Define Projection Interfaces

Define the main projection for Book and a nested projection for Chapter. The nested projection will be used to retrieve the chapter titles within each book.

package com.codersathi.springdatajpaprojection;

import java.util.List;

public interface BookProjection {
    String getTitle();
    String getAuthor();
    List<ChapterProjection> getChapters();

}

package com.codersathi.springdatajpaprojection;

public interface ChapterProjection {
        String getName();
    }

Step 3: Create Repository with Projection

Now, create a repository that uses this projection to fetch only the necessary fields.

Following is an example of how to define a query to retrieve BookProjection, including the nested ChapterProjection.

package com.codersathi.springdatajpaprojection;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface BookRepository extends CrudRepository<Book, Long> {

    List<BookProjection> findByGenre(@Param("genre") String genre);
}

Output:

The output will look like below:

[
  {
    "title": "The Great Gatsby",
    "chapters": [
      {
        "name": "Chapter 1"
      },
      {
        "name": "Chapter 2"
      }
    ],
    "author": "F. Scott Fitzgerald"
  },
  {
    "title": "To Kill a Mockingbird",
    "chapters": [
      {
        "name": "Chapter 1"
      },
      {
        "name": "Chapter 2"
      }
    ],
    "author": "Harper Lee"
  }
]

Source code is available on github.

Frequently Asked Questions (FAQs)