Mapping shows how two entities are related to each other. In many to many mapping many entities of class A can only have multiple entities in class B. Like for example suppose the two classes are Student and Courses. So if these two classes have many to many relationship then it means that each Student can have multiple Courses .And each Course can have multiple students
We will explain this with the help of an example:
We make two class Student(We named the class Stu3 but we will reference it as Student to make it more easy to understand) and Course.
Listing 1: Course class
package model;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
* @author Anurag
*/
@Entity
public class Course implements Serializable {
@Id
@GeneratedValue
@Column(name = "C_ID")
private Long id;
private String name;
private int duration;
public Course() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Course(String n, int dur) {
name = n;
duration = dur;
}
public int getDuration() {
return duration;
}
public void setDuration(int duration) {
this.duration = duration;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- We defined a class Course with fields like id, name, duration.
- We define the setter and getter function for these
- We set the id to be auto generated and also we set the name for this column to be C_ID
Listing 2: Student class
package model;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
/**
*
* @author Anurag
*/
@Entity
public class Stu3 implements Serializable {
private Long id;
private String name;
private List<Course> c;
public Stu3() {
c = new ArrayList<Course>();
}
@Id
@GeneratedValue
@Column(name = "STUDENT_ID")
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "STUDENT_Course", joinColumns = {@JoinColumn(name = "STUDENT_ID")}, inverseJoinColumns = {@JoinColumn(name = "C_ID")})
public List<Course> getC() {
return c;
}
public void setC(List<Course> c) {
this.c = c;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- We made a student class with fields like id ,name. We also made a variable c which can contain course
- We made setter and getter function for each field
- We used @Id and @GeneratedValue because we will use the field id as a primary key and its value will be auto generated
- For implementing many to many mapping we use @ManyToMany(cascade = CascadeType.ALL)
- @JoinTable(name = "STUDENT_Course", joinColumns = {@JoinColumn(name = "STUDENT_ID")}, inverseJoinColumns = {@JoinColumn(name = "C_ID")}) This is used to make a third table named Student_course which will have two columns student_id from the student(stu) class and C_ID from the course class.
Now we will define the configuration file:
Listing 3: hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernateArt</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">csanurag</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.current_session_context_class">thread</property>
<mapping class="model.Stu3"/>
<mapping class="model.Course"/>
</session-factory>
</hibernate-configuration>
- We defined the configuration parameter for the database
- We also defined the mapping class for both the classes
Now we will define the Utility class which will be used to obtain instance of session factory
Listing 4: Utility class
package Main;
/**
*
* @author Anurag
*/
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class Utility {
private static final SessionFactory sessionFactory;
static {
try {
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
Lastly we will make a class which will make this all work.
Listing 5: App2 class
package Main;
/**
*
* @author Anurag
*/
import model.Course;
import model.Stu3;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
public class App2 {
public static void main(String args[]) {
SessionFactory sf = Utility.getSessionFactory();
Session s = sf.getCurrentSession();
Transaction tx = s.beginTransaction();
Course f = new Course("J2EE", 12);
Course f2 = new Course("Hibernate", 6);
Stu3 s1 = new Stu3();
Stu3 s2 = new Stu3();
s1.setName("Anurag");
s1.getC().add(f);
s1.getC().add(f2);
s2.setName("XYZ");
s2.getC().add(f);
s.save(s1);
s.save(s2);
tx.commit();
}
}
- Firstly, We made a session instance with help of session factory object.
- Now we start the transaction and made two object for course
- Now we make two student object .
- The first student is set to have both the courses and the second student is set to have one of the courses selected by first student. So in this case multiple students have opted for one course. Similarly we see that both courses belong to first user so multiple course belong to single user.
- We save the session.
- We commit the transaction to make the changes permanent
- When the program is run then three table named Stu3, Courses, student_course are made and the student record have many to many dependency on the course table.Actually the table student_course will contain the mapping between 2 tables and have values(For this program) (1,1) , (1,2) and (2,1)
Resources:
Hibernate many to many relationship
