Last Updated on October 20, 2024 by jt

When you work in Enterprise Spring applications, you will often need to establish mappings between your entities. JPA one-to-many mapping is one such example. At the database level, one-to-many mapping means that one row in a table is mapped to multiple rows in another table.

In this post, I’ll explain how to implement JPA one-to-many mapping in a Spring Boot application.

The Example Application

To understand one-to-many mapping, think of a shopping cart that can contain many products. In the database, we will have a

Below is the ER diagram.

The Application POM

For this post, we will create a Spring Boot Maven project. The application POM is this.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.5</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>guru.springframewok</groupId>
  <artifactId>jpa-one-to-many</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>jpa-one-to-many</name>
  <description>Demo project for One to Many relationship</description>
  <properties>
    <java.version>17</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
            </exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

The Entities

We will first create a

ShoppingCart.java

package guru.springframewok.jpaonetomany.model;

import lombok.Getter;
import lombok.Setter;

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

@Getter
@Setter
@Entity
public class ShoppingCart {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @OneToMany(cascade = CascadeType.ALL,mappedBy = "shoppingCart",fetch = FetchType.EAGER)
    private Set<Product> products= new HashSet<>();

    public ShoppingCart addProduct(Product product){
        product.setShoppingCart(this);
        this.products.add(product);
        return this;
    }
}

In the preceding code,

If you are new to Lombok, I suggest going through my series of posts Spring Boot with Lombok

On Line 17, the

The

The

Finally, we have the attribute

Note: By default,

We will next create the owning side of the relationship, which is

The code of the

Product.java

package guru.springframewok.jpaonetomany.model;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.math.BigDecimal;

@Getter
@Setter
@EqualsAndHashCode(exclude = {"shopingCart"})
@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @ManyToOne
    private ShoppingCart shoppingCart;
    private String name;
    private String description;
    private BigDecimal price;

    public Product() {
    }

    public Product(String name, String description, BigDecimal price) {
        this.name=name;
        this.description = description;
        this.price = price;
    }
}

In the preceding

The Application.properties File

We are using embedded H2. We shall set its properties in the

spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:cartdb
spring.jpa.defer-datasource-initialization=true

The BootstrapData Class

We will create a

BootstrapData.java

package guru.springframewok.jpaonetomany.bootstrap;

import guru.springframewok.jpaonetomany.model.Product;
import guru.springframewok.jpaonetomany.model.ShoppingCart;
import guru.springframewok.jpaonetomany.repositories.ShoppingCartRepository;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.Set;

@Component
public class BootstrapData implements ApplicationListener<ContextRefreshedEvent> {
    private ShoppingCartRepository shoppingCartRepository;
    public BootstrapData(ShoppingCartRepository shoppingCartRepository) {
        this.shoppingCartRepository=shoppingCartRepository;
    }

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        ShoppingCart shoppingCart = new ShoppingCart();
        Product product1=new Product("Luxor Pen","Perfect gift to your office colleague",new BigDecimal(88));
        Product product2=new Product("Wind of life","A best seller for self motivation",new BigDecimal(30));
        shoppingCart.addProduct(product1);
        shoppingCart.addProduct(product2);
        shoppingCartRepository.save(shoppingCart);
        loadData();
    }

    private void loadData() {
        Iterable<ShoppingCart> cart=shoppingCartRepository.findAll();
        for(ShoppingCart shoppingCartIterable: cart){
           shoppingCartIterable.getProducts().stream().forEach((items) -> {
                System.out.println(items.getName());
                System.out.println(items.getDescription());
                System.out.println(items.getPrice());
                System.out.println("_____________________");
            });
        }
    }
}

The class is a Spring component and implements the

We also have a

Running the Application

When we build and run the application, we get the following output on the console.

Let’s check the H2 console by pointing the browser to http://localhost:8080/h2-console

Then, on logging in, we can see the

Next, let’s query the

Next, let’s query the

In the preceding figure notice the foreign key column

Finally, let’s add the following before Line 28 in the

shoppingCartRepository.delete(shoppingCart);

When you rerun your application, the shopping cart will get saved first and the products will be printed on the console. But when the

You can verify this through the H2 Console. This is the effect of the

You can find the corresponding code of this post on Github.

To learn in-depth about different types of JPA relationships, you can go through my Udemy course Hibernate and Spring Data JPA: Beginner to Guru