In this tutorial, we will research together on a final annotation in JPA, beside @ManyToOne, @OneToOne, @OneToMany annotation, to express the relationship between any two tables in the database. That is the annotation @ManyToMany! In case, any two tables have many-many relationships, such as a developer can do in many different projects and a project can have many developers, then you can use the @ManyToMany annotation to express that relationship. Let’s find out how to use this annotation in this tutorial.
First, I will create a Maven project as an example:
I will use Hibernate as JPA implementation so I will add Hibernate dependency as follows:
|
1 2 3 4 5 |
<dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.2.11.Final</version> </dependency> |
MySQL Connector:
|
1 2 3 4 5 |
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>6.0.6</version> </dependency> |
Assume, now I define the structure of the two tables: developer and project as follows:
|
1 2 3 4 5 6 7 8 9 10 11 |
CREATE TABLE `developer` ( `id` int(11) NOT NULL, `name` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; CREATE TABLE `project` ( `id` int(11) NOT NULL, `name` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`), ) ENGINE=InnoDB DEFAULT CHARSET=utf8; |
As you can see, I’ve defined the developer table with two columns, id and name, where id is the primary key. In the project table, I also define the two columns id and name with the primary key is id.
Here, we can not define foreign key columns from one table to another because it will not show the relationship many-many between them. For example: if you define a project_id column in the developer table, you only define a project that the developer belongs to, can not define multiple projects. In contrast to the project table, it is same.
One solution to resolve this problem that we can do is to define a table to show the many-many relationships between the developer and the project. This table will contain the developer id corresponding to the project’s id, also known as joinTable, as follows:
|
1 2 3 4 5 6 |
CREATE TABLE `developer_project` ( `developer_id` int(11) NOT NULL, `project_id` int(11) NOT NULL, FOREIGN KEY (`developer_id`) REFERENCES `developer` (`id`), FOREIGN KEY (`project_id`) REFERENCES `project` (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; |
Now, we can define: a developer can belong to many projects and a project can host many developers.
The Entity class of 2 tables developer and project, now can be defined with the @ManyToMany annotation as follows:
Entity Developer:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
package com.huongdanjava.jpamanytomany; import javax.persistence.*; import java.util.Collection; @Entity @Table public class Developer { @Id @GeneratedValue private Integer id; @Column private String name; @ManyToMany @JoinTable(name = "developer_project", joinColumns = @JoinColumn(name = "developer_id"), inverseJoinColumns = @JoinColumn(name = "project_id")) private Collection<Project> projects; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Collection<Project> getProjects() { return projects; } public void setProjects(Collection<Project> projects) { this.projects = projects; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Developer developer = (Developer) o; if (!id.equals(developer.id)) return false; return name.equals(developer.name); } @Override public int hashCode() { int result = id.hashCode(); result = 31 * result + name.hashCode(); return result; } } |
Entity Project:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
package com.huongdanjava.jpamanytomany; import javax.persistence.*; import java.util.Collection; @Entity @Table public class Project { @Id @GeneratedValue private Integer id; @Column private String name; @ManyToMany(mappedBy = "projects") private Collection<Developer> developers; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Collection<Developer> getDevelopers() { return developers; } public void setDevelopers(Collection<Developer> developers) { this.developers = developers; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Project project = (Project) o; if (!id.equals(project.id)) return false; return name.equals(project.name); } @Override public int hashCode() { int result = id.hashCode(); result = 31 * result + name.hashCode(); return result; } } |
We will put the @ManyToMany annotation along with declaring a Collection variable in both the Developer and Project entities, and to show the relationship many-many, we will use another annotation @JoinTable in one of these two entities. You can set @JoinTable annotation anywhere, if this annotation is in the @Developer entity, then in the Project entity you must declare the mappedBy attribute in the @ManyToMany annotation and vice versa.
In the @JoinTable annotation that we defined in the Developer entity, here we have three attributes that we need to declare:
- name: it declares the name of the joinTable (that is developer_project table),
- joinColumns: it is the name of the column in the joinTable that developer table will be foreign key to,
- inverseJoinColumns: it is the name of the column in the joinTable that project table will be foreign key to.
OK, so we have defined the entity Developer and entity Project with @ManyToMany annotation to demonstrate the many-many relationships between developer and project tables. Now let’s take an example to see how it works.
I will add the configuration file for JPA, persistence.xml, located in the /src/main/resources/META-INF directory with the following contents:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence_2_1.xsd"> <persistence-unit name="jpaexample" transaction-type="RESOURCE_LOCAL"> <class>com.huongdanjava.jpamanytomany.Developer</class> <class>com.huongdanjava.jpamanytomany.Project</class> <exclude-unlisted-classes>true</exclude-unlisted-classes> <properties> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpaexample" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="123456" /> <property name="hibernate.format_sql" value="true" /> <property name="hibernate.use_sql_comments" value="true" /> </properties> </persistence-unit> </persistence> |
Suppose you have the following data in your database:
When running the following example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package com.huongdanjava.jpamanytomany; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.EntityTransaction; import javax.persistence.Persistence; public class Application { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpaexample"); EntityManager em = emf.createEntityManager(); EntityTransaction transaction = em.getTransaction(); Project project = em.find(Project.class, 1); System.out.println("Project name: " + project.getName()); project.getDevelopers().forEach( (developer) -> System.out.println(developer.getName()) ); em.close(); emf.close(); } } |
The results will look like this:
