Many To Many Mapping | Mappings | Hibernate Tutorial

Introduction

In Hibernate, a Many-to-Many relationship is a type of association where multiple records in one entity are associated with multiple records in another entity. This kind of mapping requires an intermediary table (also known as a join table) to manage the associations.

Understanding the Many-to-Many Relationship

Consider a scenario where we have two entities: Students and Courses. A student can enroll in multiple courses, and a course can have multiple students. This relationship can be represented as follows:

Students: John, Jane, Bob
Courses: Math, Science, History

In this case, we need a join table called Student_Courses to keep track of which student is enrolled in which course.

Setting Up Entities

We will create two entity classes: Student and Course. Below is the implementation using Hibernate annotations.

Student Entity

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

                @Entity
                public class Student {
                    @Id
                    @GeneratedValue(strategy = GenerationType.IDENTITY)
                    private Long id;
                    private String name;

                    @ManyToMany
                    @JoinTable(
                        name = "student_courses",
                        joinColumns = @JoinColumn(name = "student_id"),
                        inverseJoinColumns = @JoinColumn(name = "course_id")
                    )
                    private Set courses;

                    // Getters and Setters
                }

Course Entity

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

                @Entity
                public class Course {
                    @Id
                    @GeneratedValue(strategy = GenerationType.IDENTITY)
                    private Long id;
                    private String title;

                    @ManyToMany(mappedBy = "courses")
                    private Set students;

                    // Getters and Setters
                }

In the Student entity, we are using the @ManyToMany annotation to indicate the relationship, and we are specifying a join table student_courses to manage the associations between Student and Course.

Persisting Data

To persist data in a many-to-many relationship, we can create instances of both entities and establish the relationships between them. Here’s how to do it:

                Session session = sessionFactory.openSession();
                Transaction tx = session.beginTransaction();

                Student student1 = new Student();
                student1.setName("John");

                Course course1 = new Course();
                course1.setTitle("Math");

                student1.getCourses().add(course1);
                course1.getStudents().add(student1);

                session.save(student1);
                session.save(course1);

                tx.commit();
                session.close();

Retrieving Data

To retrieve data from a many-to-many relationship, we can query one of the entities and access the associated entities. For example, if we want to fetch all courses for a specific student:

                Session session = sessionFactory.openSession();
                Student student = session.get(Student.class, 1L);
                Set courses = student.getCourses();

                for (Course course : courses) {
                    System.out.println(course.getTitle());
                }
                session.close();

Conclusion

Many-to-many mapping is a powerful feature in Hibernate that allows for complex relationships between entities. By using a join table, we can effectively manage and persist these relationships, enabling rich data interactions in our applications.

Many-to-Many Mapping in Hibernate