Entity Relationships in JPA

Introduction

Real applications are rarely made of isolated tables. A student enrolls in a course; an order has line items; a blog post has comments. JPA lets you model these connections directly in your Java classes using relationship annotations, and Hibernate translates them into foreign keys and joins automatically. This lesson builds a Student-and-Course relationship: each course can have many students, and each student belongs to one course.

Relationship Types in JPA

JPA supports four relationship annotations, each describing how many rows on one side relate to how many rows on the other.

@OneToMany and @ManyToOne are almost always used together, as two sides of the same relationship. This lesson focuses on that pair, since it's the one you'll reach for most often.

The Owning Side: @ManyToOne

In a Student-Course relationship, Student is the 'many' side — many students can belong to the same course — so Student holds the foreign key column in the database, and @ManyToOne goes on its Course field. This is called the owning side of the relationship.

@Entity
public class Student {

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

    private String name;

    @ManyToOne
    @JoinColumn(name = "course_id")
    private Course course;

    // getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public Course getCourse() { return course; }
    public void setCourse(Course course) { this.course = course; }
}

@JoinColumn(name = "course_id") tells Hibernate exactly what to name the foreign key column on the student table. Without it, Hibernate picks a default name automatically, but being explicit keeps your schema predictable.

The Inverse Side: @OneToMany

Course is the 'one' side, so it gets a collection of students annotated with @OneToMany. The mappedBy attribute is essential here — it tells Hibernate that this side does not own the relationship, and points to the field name on Student that already defines the foreign key.

@Entity
public class Course {

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

    private String title;

    @OneToMany(mappedBy = "course")
    private List<Student> students = new ArrayList<>();

    // getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }

    public List<Student> getStudents() { return students; }
    public void setStudents(List<Student> students) { this.students = students; }
}

Fetch Types

Every relationship has a fetch type controlling when the related data actually loads from the database. @ManyToOne defaults to eager loading (fetched immediately with the owning entity); @OneToMany defaults to lazy loading (fetched only when explicitly accessed).

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "course_id")
private Course course;

Avoiding Infinite JSON Recursion

If you return a Course directly from a controller, Jackson tries to serialize its list of Student objects — and each Student tries to serialize its Course back — producing an infinite loop and a StackOverflowError. The @JsonIgnore annotation on one side breaks the cycle.

@OneToMany(mappedBy = "course")
@com.fasterxml.jackson.annotation.JsonIgnore
private List<Student> students = new ArrayList<>();

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You can now model real relationships between entities and understand how Hibernate turns them into foreign keys and joins. Next, you'll add validation to your API so invalid data — missing names, malformed emails — gets rejected automatically before it ever reaches your database.