Shailendra Singh
Shail's Blog

Shail's Blog

One-to-Many Relationship Spring Data JPA

One-to-Many Relationship Spring Data JPA

Shailendra Singh's photo
Shailendra Singh

Published on Sep 20, 2021

3 min read

In this article, we will continue our learning about implementing relationships between entities in Spring Boot JPA. Today we will learn about implementing One-to-Many relationship.

One-to-Many Relationship

A one-to-many relationship is a type of cardinality that refers to the relationship between two entities A and B in which an element of A may be linked to many elements of B, but a member of B is linked to only one element of A.

Let's take an example of person and credit card, a person may have more than one credit card but one credit card is linked with only one person.

The person and passport classes are using Lombok to reduce boilerplate code, I suggest you to go through Lombok article .

@Table(name = "person")
@Getter @Setter @Builder
public class Person {

    @Column(name = "person_id")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer personId;

    @Column(name = "person_name")
    private String personName;    

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinTable(name = "person_card_mapping",
                joinColumns = @JoinColumn(name = "person_id"),
                inverseJoinColumns = @JoinColumn(name = "card_id"))
    private List<Card> cards;


@Table(name = "card")
@Getter @Setter @Builder
public class Card {

    @Column(name = "card_id")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer cardId;

    @Column(name = "card_no")
    private String cardNo;

    @Column(name = "cardholder_name")
    private String cardholderName;

    @Column(name = "expiry_month")
    private String expiryMonth;

    @Column(name = "expiry_year")
    private String expiryYear;    

The relationship in the ER diagram is represented as follow:


The mapping is implemented in database using a mapping table which stores the primary key or identifying column from both the entities.

@JoinTable is used to specify the name of mapping table and joining column details.

name = "person_card_mapping" specifies the mapping table name where the primary keys will be stored.

joinColumns = @JoinColumn(name = "person_id") specifies that from person table person_id column will be used to implement mapping.

inverseJoinColumns = @JoinColumn(name = "card_id")) specifies that from card table card_id column will be used to implement mapping.


Let's see a test case to test the unidirectional one-to-many relationship between Person and Cards.

public class OneToManyMappingTests {

    private PersonRepository personRepo;

    private Person person = null;
    private Card card1 = null;
    private Card card2 = null;

    private Integer personId;

    public void setup() {

        card1 = Card.builder()
                .cardholderName("John Doe")

        card2 = Card.builder()
                .cardholderName("John Doe")

        List<Card> cards = new ArrayList<>();

        person =  Person.builder()
                .personName("John Doe")

        person =;
        personId = person.getPersonId();

    public void testOneToMany() {

        Person person  = personRepo.findById(personId).orElse(null);

        assertEquals("4578963214502354", person.getCards().get(0).getCardNo());
        assertEquals("4111111111111111", person.getCards().get(1).getCardNo());



On running this test case, we will find all these test cases runs successfully and verifies that our implementation is correct.


In this article, we learnt about implementation of one-to-many mapping relationship in Spring Data JPA. The other mapping relationship in Spring Data JPA will be discussed in further post.

Check this article for implementing One-to-One mapping.

Check this article for implementing Many-to-Many mapping.

You can find the source code of this post @ Github

Share this