JPA @OneToMany Annotation

In this blog post, we will learn important JPA @OneToMany annotation with an example.

Jakarta Persistence API (JPA) is a powerful technology that simplifies the management of relational data in Java applications. One of the most common relationships between entities is the one-to-many relationship, where one entity is associated with multiple instances of another entity. JPA provides the @OneToMany annotation to map this type of relationship seamlessly. 

Understanding @OneToMany Annotation

The @OneToMany annotation is used to establish a one-to-many relationship between two entities in JPA. It indicates that one instance of the source entity (parent) is related to multiple instances of the target entity (children). In other words, each parent entity can have multiple associated child entities.

Here are the most commonly used attributes of the @OneToMany annotation: 

targetEntity: Specifies the target entity class to which the relationship is mapped. It is required when the target entity is not directly inferred from the type of the collection. 

mappedBy: Defines the inverse side of the relationship. It represents the field in the target entity that owns the relationship (i.e., the field that contains the reference to the source entity). It is used when dealing with bidirectional relationships and must match the name of the field in the target entity. 

cascade: Specifies the cascade operations that should be propagated from the parent entity to the child entities. Cascade operations include persist, merge, remove, refresh, and detach. Use the CascadeType enum to specify one or more cascade types. 

fetch: Defines the fetching strategy for the association. It determines when the associated child entities should be loaded from the database. Two common options are FetchType.LAZY (loads the child entities on-demand when accessed) and FetchType.EAGER (loads the child entities immediately with the parent entity).

orphanRemoval: Specifies whether orphaned child entities (entities that are no longer associated with a parent) should be automatically removed from the database. When set to true, orphaned child entities are deleted when they are removed from the collection in the parent entity. 

@OneToMany Annotation Example

Let's consider an example of a one-to-many relationship between an Instructor entity and multiple Course entities. Each instructor can have multiple courses, and we will use the @OneToMany annotation to map this relationship:

Instructor JPA Entity -

import java.util.ArrayList;
import java.util.List;

import javax.persistence.*;

@Table(name = "instructor")
public class Instructor {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    @OneToMany(cascade = CascadeType.ALL)
    private List <Course> courses = new ArrayList <Course> ();
    // getter / setter method

Course JPA Entity -

import javax.persistence.*;

@Table(name = "course")
public class Course {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "title")
    private String title;
    // getter / setter methods 
In this example, the Instructor entity has field courses annotated with @OneToMany annotation.

The cascade attribute in the @OneToMany annotation defines how operations (e.g., persist, remove) on the parent entity should be cascaded to the child entities. In the example, CascadeType.ALL means that all operations on the Instructor entity will also apply to its associated Course entities.


The @OneToMany annotation in JPA is a powerful tool for mapping one-to-many relationships between entities. With this annotation, developers can create sophisticated data models that accurately represent the associations between parent and child entities. 

By understanding the various attributes of @OneToMany, including cascading operations, fetching strategies, and orphan removal, you can efficiently manage one-to-many relationships in your JPA-powered applications. 

With the @OneToMany annotation, JPA makes it easy to navigate and manage related entities, providing a seamless and efficient approach to working with complex data structures.

Complete JPA One-to-Many Mapping Examples

JPA Hibernate One to Many Unidirectional Mapping Example