In the previous article, I wrote about how to define and use a one-to-one relationship with Spring Data JPA and MySQL in a Spring Boot application.

In this article, you'll learn how to map a one-to-many database relationship using Spring Data JPA in a Spring Boot and MySQL application.


We need both spring-data-starter-data-jpa and mysql-connector-java dependencies to use Spring Data JPA with the MySQL database in Spring Boot.

If you are using Gradle, add the following dependencies to your build.gradle file:

implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'mysql:mysql-connector-java'

If you are using Maven, include the following dependencies to your pom.xml file:


Want to create a new Spring Boot project from scratch? Just use Spring Initializr web tool to bootstrap a new application with the above dependencies.

Configure MySQL Database

Spring Boot auto-configures the DataSource bean for in-memory databases like H2 database, HSQLDB, and Apache Derby. Since we are using MySQL, we need to explicitly define the database connection properties in a properties file.

Open the file in your favorite editor and add the following properties:

# MySQL connection properties

# Log JPA queries
# Comment this in production

# Drop and create new tables (create, create-drop, validate, update)
# Only for testing purposes - comment this in production

# Hibernate SQL dialect

Spring Boot will automatically configure a DataSource bean using the above properties. Do not forget to change the spring.datasource.username and spring.datasource.password properties to match your MySQL database installation.

The hibernate property spring.jpa.hibernate.ddl-auto = create will automatically create database tables based on the entity classes in your application on application startup.

The createDatabaseIfNotExist=true configuration property, which we have included in spring.datasource.url, automatically creates the database schema if it doesn't already exist.

One-To-Many Relationship

A one-to-many relationship refers to the relationship between two entities/tables A and B in which one element/row of A may only be linked to many elements/rows of B, but a member of B is linked to only one element/row of A.

For instance, think of A as a book and B as pages. A book can have many pages, but a page can only exist in one book, forming a one-to-many relationship. The opposite of one-to-many is a many-to-one relationship.

Let us model the above relationship in the database by creating two tables, one for the books and another for the pages, as shown below in an Entity-Relationship (ER) diagram:

Spring Data JPA One To Many Mapping

The one-to-many relationship is defined by the foreign key book_id in the pages table.

Create Entities

The next step is to create the Book and Page entities and define the one-to-many relationship mapping, as shown below:


import javax.persistence.*;
import java.util.Set;

@Table(name = "books")
public class Book implements Serializable {

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

    private String title;
    private String author;
    @Column(unique = true)
    private String isbn;

    @OneToMany(mappedBy = "book", fetch = FetchType.LAZY,
            cascade = CascadeType.ALL)
    private Set<Page> pages;

    public Book() {

    public Book(String title, String author, String isbn) {
        this.title = title; = author;
        this.isbn = isbn;

    // getters and setters, equals(), toString() .... (omitted for brevity)


import javax.persistence.*;

@Table(name = "pages")
public class Page implements Serializable {

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

    private int number;
    private String content;
    private String chapter;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "book_id", nullable = false)
    private Book book;

    public Page() {

    public Page(int number, String content, String chapter, Book book) {
        this.number = number;
        this.content = content;
        this.chapter = chapter; = book;

    // getters and setters, equals(), toString() .... (omitted for brevity)

Both Book and Page classes are annotated with the Entity annotation to indicate that they are JPA entities.

The @Table annotation is used to specify the name of the database table that should be mapped to this entity.

The id attributes are annotated with both @Id and @GeneratedValue annotations. The former indicates that they are the primary keys of the entities. The latter defines the primary key generation strategy. In the above case, we have declared that the primary key should be an AUTO INCREMENT field.

@OneToMany Annotation

A one-to-many relationship between two entities is defined using the @OneToMany annotation in Spring Data JPA. It declares the mappedBy element to indicate the entity that owns the bidirectional relationship. Usually, the child entity owns the relationship, and the parent entity contains the @OneToMany annotation.

@ManyToOne Annotation

The @ManyToOne annotation defines a many-to-one relationship between two entities in Spring Data JPA. The child entity that has the join column is called the owner of the relationship defined using the @ManyToOne annotation.

@JoinColumn Annotation

The @JoinColumn annotation is used to specify the foreign key column in the relationship owner. The inverse side of the relationship sets the mappedBy attribute to indicate that the relationship is owned by the other entity.

Create Repositories

Let us now define the repository interfaces to store and access the data from the database. We'll be extending our repositories from Spring Data JPA's CrudRepository interface that provides methods for generic CRUD operations.

package com.attacomsian.jpa.one2many.repositories;


public interface BookRepository extends CrudRepository<Book, Long> {

    Book findByIsbn(String isbn);

package com.attacomsian.jpa.one2many.repositories;


import java.util.List;

public interface PageRepository extends CrudRepository<Page, Long> {

    List<Page> findByBook(Book book, Sort sort);

In the above repositories, we also defined some derived query methods like findByIsbn() to fetch a book by its ISBN number.

That's it. You have successfully defined a one-to-many relationship mapping in Spring Data JPA. You don't need to implement the above interfaces thanks to Spring Data JPA.

Create an Application Class

Let us now create the main application class for the Spring Boot console application to test our one-to-many relationship mapping:

package com.attacomsian.jpa;

import com.attacomsian.jpa.one2many.repositories.BookRepository;
import com.attacomsian.jpa.one2many.repositories.PageRepository;
import com.attacomsian.jpa.one2one.repositories.AddressRepository;
import com.attacomsian.jpa.one2one.repositories.UserRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

public class Application {

    public static void main(String[] args) {, args);

    public CommandLineRunner mappingDemo(BookRepository bookRepository,
                                         PageRepository pageRepository) {
        return args -> {

            // create a new book
            Book book = new Book("Java 101", "John Doe", "123456");

            // save the book

            // create and save new pages
   Page(1, "Introduction contents", "Introduction", book));
   Page(65, "Java 8 contents", "Java 8", book));
   Page(95, "Concurrency contents", "Concurrency", book));

Run the Application

Next, run the application to see the output. If you are using Gradle, execute the following command to start the application:

$ ./gradlew bootRun

For Maven, type the following command to launch the application:

$ ./mvnw spring-boot:run

Once the application is started, you should see the following lines printed on the console:

Hibernate: drop table if exists books
Hibernate: drop table if exists pages
Hibernate: create table books (id bigint not null auto_increment, author varchar(255), isbn varchar(255), title varchar(255), primary key (id)) engine=InnoDB
Hibernate: create table pages (id bigint not null auto_increment, chapter varchar(255), content varchar(255), number integer not null, book_id bigint not null, primary key (id)) engine=InnoDB
Hibernate: insert into books (author, isbn, title) values (?, ?, ?)
Hibernate: insert into pages (book_id, chapter, content, number) values (?, ?, ?, ?)
Hibernate: insert into pages (book_id, chapter, content, number) values (?, ?, ?, ?)
Hibernate: insert into pages (book_id, chapter, content, number) values (?, ?, ?, ?)

Source Code: Download the complete source code from GitHub available under MIT license.


That's all. In this article, you learned how to map and use a one-to-many relationship in Spring Data JPA and Hibernate.

Don't forget to join the mailing list if you want to be the first to know when new tutorials are available.

Further Reading

To learn about Spring Data JPA, check out the following articles:

✌️ Like this article? Follow me on Twitter and LinkedIn. You can also subscribe to RSS Feed.