Ruhezustand Viele zu Viele Annotation Tutorial

1. Einleitung

In diesem kurzen Tutorial sehen wir uns kurz an, wie die Annotation @ManyToMany zum Festlegen dieser Art von Beziehungen im Ruhezustand verwendet werden kann.

2. Ein typisches Beispiel

Beginnen wir mit einem einfachen Entitätsbeziehungsdiagramm, das die Viele-zu-Viele-Zuordnung zwischen zwei Entitäten, Mitarbeiter und Projekt zeigt:

In diesem Szenario kann jeder Mitarbeiter mehreren Projekten zugewiesen werden, und für ein Projekt können mehrere Mitarbeiter arbeiten, was zu einer Viele-zu-Viele-Zuordnung zwischen beiden führt.

Wir haben eine Mitarbeitertabelle mit employee_id als Primärschlüssel und eine Projekttabelle mit project_id als Primärschlüssel. Hier ist eine Join-Tabelle employee_project erforderlich, um beide Seiten zu verbinden.

3. Datenbank-Setup

Nehmen wir an, wir haben eine bereits erstellte Datenbank mit dem Namen spring_hibernate_many_to_many.

Wir müssen auch die erstellen Mitarbeiter und Projekt Tabellen zusammen mit dem EMPLOYEE_PROJECT Tisch mit beitreten employee_id und project_id als Fremdschlüssel:

CREATE TABLE `employee` ( `employee_id` int(11) NOT NULL AUTO_INCREMENT, `first_name` varchar(50) DEFAULT NULL, `last_name` varchar(50) DEFAULT NULL, PRIMARY KEY (`employee_id`) ) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8; CREATE TABLE `project` ( `project_id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(50) DEFAULT NULL, PRIMARY KEY (`project_id`) ) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8; CREATE TABLE `employee_project` ( `employee_id` int(11) NOT NULL, `project_id` int(11) NOT NULL, PRIMARY KEY (`employee_id`,`project_id`), KEY `project_id` (`project_id`), CONSTRAINT `employee_project_ibfk_1` FOREIGN KEY (`employee_id`) REFERENCES `employee` (`employee_id`), CONSTRAINT `employee_project_ibfk_2` FOREIGN KEY (`project_id`) REFERENCES `project` (`project_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

Wenn die Datenbank eingerichtet ist, besteht der nächste Schritt in der Vorbereitung der Maven-Abhängigkeiten und der Konfiguration des Ruhezustands. Informationen hierzu finden Sie im Artikel im Handbuch zu Hibernate4 mit Spring

4. Die Modellklassen

Die Modellklassen Mitarbeiter und Projekt müssen mit JPA-Anmerkungen erstellt werden:

@Entity @Table(name = "Employee") public class Employee { // ... @ManyToMany(cascade = { CascadeType.ALL }) @JoinTable( name = "Employee_Project", joinColumns = { @JoinColumn(name = "employee_id") }, inverseJoinColumns = { @JoinColumn(name = "project_id") } ) Set projects = new HashSet(); // standard constructor/getters/setters }
@Entity @Table(name = "Project") public class Project { // ... @ManyToMany(mappedBy = "projects") private Set employees = new HashSet(); // standard constructors/getters/setters }

Wie wir sehen können, beziehen sich sowohl die Employee- Klasse als auch die Project- Klasse aufeinander, was bedeutet, dass die Zuordnung zwischen ihnen bidirektional ist.

Um eine Viele-zu-Viele-Zuordnung zuzuordnen , verwenden wir die Annotationen @ManyToMany , @JoinTable und @JoinColumn . Schauen wir sie uns genauer an.

Die Annotation @ManyToMany wird in beiden Klassen verwendet, um die Viele-zu-Viele-Beziehung zwischen den Entitäten zu erstellen.

Diese Assoziation hat zwei Seiten, nämlich die besitzende Seite und die umgekehrte Seite. In unserem Beispiel ist die Besitzerseite Employee, sodass die Join-Tabelle auf der Besitzerseite mithilfe der Annotation @JoinTable in der Employee- Klasse angegeben wird. Mit @JoinTable wird die Join / Link-Tabelle definiert. In diesem Fall ist es Employee_Project.

Die Annotation @JoinColumn wird verwendet, um die Join- / Verknüpfungsspalte mit der Haupttabelle anzugeben. Hier lautet die Join-Spalte employee_id und project_id die inverse Join-Spalte, da sich Project auf der inversen Seite der Beziehung befindet.

In der Projektklasse, die mappedBy wird Attribut in der verwendeten @ManyToMany Anmerkung , um anzuzeigen , dass die Mitarbeiter Sammlung durch die abgebildet wird Projekte Sammlung der Eigentümers Seite.

5. Ausführung

Um die Viele-zu-Viele-Annotation in Aktion zu sehen, können wir den folgenden JUnit-Test schreiben:

public class HibernateManyToManyAnnotationMainIntegrationTest { private static SessionFactory sessionFactory; private Session session; // ... @Test public void givenData_whenInsert_thenCreatesMtoMrelationship() { String[] employeeData = { "Peter Oven", "Allan Norman" }; String[] projectData = { "IT Project", "Networking Project" }; Set projects = new HashSet(); for (String proj : projectData) { projects.add(new Project(proj)); } for (String emp : employeeData) { Employee employee = new Employee(emp.split(" ")[0], emp.split(" ")[1]); assertEquals(0, employee.getProjects().size()); employee.setProjects(projects); session.persist(employee); assertNotNull(employee); } } @Test public void givenSession_whenRead_thenReturnsMtoMdata() { @SuppressWarnings("unchecked") List employeeList = session.createQuery("FROM Employee") .list(); assertNotNull(employeeList); for(Employee employee : employeeList) { assertNotNull(employee.getProjects()); } } // ... }

Wir können die Viele-zu-Viele-Beziehung zwischen den beiden in der Datenbank erstellten Entitäten sehen: die Tabellen employee , project und employee_project mit Beispieldaten, die die Beziehung darstellen.

6. Fazit

In diesem Tutorial haben wir gesehen, wie Sie Zuordnungen mit den vielen-zu-vielen-Anmerkungen von Hibernate erstellen. Dies ist ein praktischeres Gegenstück zum Erstellen von XML-Zuordnungsdateien.

Den Quellcode dieses Tutorials finden Sie auf GitHub.