In this example you will learn how to map many-to-many relationship using Hibernate Annotations. Consider the following relationship between Student and Course entity.
According to the relationship a student can enroll in any number of courses and the course can have any number of students.
To create this relationship you need to have a STUDENT, COURSE and STUDENT_COURSE table. The relational model is shown below.
To create the STUDENT, COURSE and STUDENT_COURSE table you need to create the following Java Class files.
Student class is used to create the STUDENT and STUDENT_COURSE table.
01.
package
com.vaannila.student;
02.
03.
import
java.util.HashSet;
04.
import
java.util.Set;
05.
06.
import
javax.persistence.CascadeType;
07.
import
javax.persistence.Column;
08.
import
javax.persistence.Entity;
09.
import
javax.persistence.GeneratedValue;
10.
import
javax.persistence.Id;
11.
import
javax.persistence.JoinColumn;
12.
import
javax.persistence.JoinTable;
13.
import
javax.persistence.ManyToMany;
14.
import
javax.persistence.Table;
15.
16.
@Entity
17.
@Table
(name =
"STUDENT"
)
18.
public
class
Student {
19.
20.
private
long
studentId;
21.
private
String studentName;
22.
private
Set courses =
new
HashSet(
0
);
23.
24.
public
Student() {
25.
}
26.
27.
public
Student(String studentName) {
28.
this
.studentName = studentName;
29.
}
30.
31.
public
Student(String studentName, Set courses) {
32.
this
.studentName = studentName;
33.
this
.courses = courses;
34.
}
35.
36.
@Id
37.
@GeneratedValue
38.
@Column
(name =
"STUDENT_ID"
)
39.
public
long
getStudentId() {
40.
return
this
.studentId;
41.
}
42.
43.
public
void
setStudentId(
long
studentId) {
44.
this
.studentId = studentId;
45.
}
46.
47.
@Column
(name =
"STUDENT_NAME"
, nullable =
false
, length =
100
)
48.
public
String getStudentName() {
49.
return
this
.studentName;
50.
}
51.
52.
public
void
setStudentName(String studentName) {
53.
this
.studentName = studentName;
54.
}
55.
56.
@ManyToMany
(cascade = CascadeType.ALL)
57.
@JoinTable
(name =
"STUDENT_COURSE"
, joinColumns = {
@JoinColumn
(name =
"STUDENT_ID"
) }, inverseJoinColumns = {
@JoinColumn
(name =
"COURSE_ID"
) })
58.
public
Set getCourses() {
59.
return
this
.courses;
60.
}
61.
62.
public
void
setCourses(Set courses) {
63.
this
.courses = courses;
64.
}
65.
66.
}
Course class is used to create the COURSE table.
01.
package
com.vaannila.student;
02.
03.
import
javax.persistence.Column;
04.
import
javax.persistence.Entity;
05.
import
javax.persistence.GeneratedValue;
06.
import
javax.persistence.Id;
07.
import
javax.persistence.Table;
08.
09.
@Entity
10.
@Table
(name=
"COURSE"
)
11.
public
class
Course {
12.
13.
private
long
courseId;
14.
private
String courseName;
15.
16.
public
Course() {
17.
}
18.
19.
public
Course(String courseName) {
20.
this
.courseName = courseName;
21.
}
22.
23.
@Id
24.
@GeneratedValue
25.
@Column
(name=
"COURSE_ID"
)
26.
public
long
getCourseId() {
27.
return
this
.courseId;
28.
}
29.
30.
public
void
setCourseId(
long
courseId) {
31.
this
.courseId = courseId;
32.
}
33.
34.
@Column
(name=
"COURSE_NAME"
, nullable=
false
)
35.
public
String getCourseName() {
36.
return
this
.courseName;
37.
}
38.
39.
public
void
setCourseName(String courseName) {
40.
this
.courseName = courseName;
41.
}
42.
43.
}
01.
"1.0"
encoding=
"UTF-8"
?>
02.
03.
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
05.
06.
07.
"hibernate.connection.driver_class"
> org.hsqldb.jdbcDriver
08.
"hibernate.connection.url"
> jdbc:hsqldb:hsql:
//localhost
09.
"hibernate.connection.username"
>sa
10.
"connection.password"
>
11.
"connection.pool_size"
>
1
12.
"hibernate.dialect"
> org.hibernate.dialect.HSQLDialect
13.
"show_sql"
>
true
14.
"hbm2ddl.auto"
>create-drop
15.
class
=
"com.vaannila.student.Student"
/>
16.
class
=
"com.vaannila.student.Course"
/>
17.
18.
01.
package
com.vaannila.student;
02.
03.
import
java.util.HashSet;
04.
import
java.util.Set;
05.
06.
import
org.hibernate.HibernateException;
07.
import
org.hibernate.Session;
08.
import
org.hibernate.Transaction;
09.
10.
import
com.vaannila.util.HibernateUtil;
11.
12.
public
class
Main {
13.
14.
public
static
void
main(String[] args) {
15.
16.
Session session = HibernateUtil.getSessionFactory().openSession();
17.
Transaction transaction =
null
;
18.
try
{
19.
transaction = session.beginTransaction();
20.
21.
Set courses =
new
HashSet();
22.
courses.add(
new
Course(
"Maths"
));
23.
courses.add(
new
Course(
"Computer Science"
));
24.
25.
Student student1 =
new
Student(
"Eswar"
, courses);
26.
Student student2 =
new
Student(
"Joe"
, courses);
27.
session.save(student1);
28.
session.save(student2);
29.
30.
transaction.commit();
31.
}
catch
(HibernateException e) {
32.
transaction.rollback();
33.
e.printStackTrace();
34.
}
finally
{
35.
session.close();
36.
}
37.
38.
}
39.
}
The STUDENT table has two records.
The COURSE table has two records.
The STUDENT_COURSE table has four records to link the student and courses.
Each student has enrolled in the same two courses, this illustrates the many-to-many mapping.
The folder structure of the example is shown below.