Spring Data JPA findBy Child Property

A common requirement is to query an entity based on the properties of its associated child entities. In this post, we will explore how to perform such queries using Spring Data JPA.

Spring Data JPA findBy Child Property Example

To demonstrate this use case, consider an Author entity having a one-to-many relationship with a Book entity:

Author Entity:

public class Author {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author")
    private List<Book> books;

    // getters, setters, constructors, etc.

Book Entity:

public class Book {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String genre;

    @JoinColumn(name = "author_id")
    private Author author;

    // getters, setters, constructors, etc.

In the above JPA entities, an Author can have multiple Book entities associated with them.

Querying by Child's Property 

Now, let's assume you want to fetch all authors who have written a book of a certain genre. Here's how you can accomplish that with Spring Data JPA:

public interface AuthorRepository extends JpaRepository<Author, Long> {

    List<Author> findByBooks_Genre(String genre);

In the findByBooks_Genre method, the underscore (_) enables property expressions, signifying traversal into the books association of the Author entity and then filtering by the genre property of the Book entity.

More Examples 

Using Multiple Conditions: To find authors based on multiple properties of their books:

List<Author> findByBooks_TitleAndBooks_Genre(String title, String genre);

Using In Clause: If you want to find authors who have written books in any of a list of genres:

List<Author> findByBooks_GenreIn(List<String> genres);

Using Distinct: To ensure that the results do not have duplicate authors, you can leverage distinct:

List<Author> findDistinctByBooks_Genre(String genre);

Tips and Best Practices 

Optimize Queries: While the above methods are concise and easy to implement, be aware of the SQL generated underneath. Depending on your database schema and relationships, some queries might lead to the N+1 problem. Utilize tools like Hibernate's @Fetch annotation or join fetch clauses to optimize such queries. 

Maintain Readability: While Spring Data JPA's method-based queries are powerful, they can become quite long and unreadable. If the method name becomes too cumbersome, consider using the @Query annotation to provide a JPQL or SQL query. 

Indexing: Ensure that the child properties you are querying on are indexed, especially for large datasets, to avoid performance issues. 


Spring Data JPA's ability to query by child entity properties greatly simplifies data fetching tasks, especially when dealing with complex entity relationships. By leveraging its conventions, developers can quickly implement a wide range of queries without having to manually write SQL or JPQL. As always, while the tools provided are powerful, care should be taken to ensure queries are optimized and the code remains maintainable.