Tutorial pentru hibernare de la multe la multe adnotări

1. Introducere

În acest tutorial rapid, vom analiza rapid modul în care poate fi utilizată adnotarea @ManyToMany pentru specificarea acestui tip de relații în Hibernate.

2. Un exemplu tipic

Să începem cu o diagramă simplă a relației entității - care arată asocierea mai multor la mulți dintre angajatul și proiectul a două entități :

În acest scenariu, orice angajat dat poate fi alocat mai multor proiecte și un proiect poate avea mai mulți angajați care lucrează pentru acesta, ducând la o asociere de la mulți la mulți între cei doi.

Avem un angajat de masă cu employee_id ca fiind cheia sa primară și un proiect de tabel cu PROJECT_ID ca cheia sa primară. Un tabel se alăture employee_project este necesară aici pentru a conecta ambele părți.

3. Configurarea bazei de date

Să presupunem că avem o bază de date deja creată cu numele spring_hibernate_many_to_many.

De asemenea, trebuie să creeze angajaților și de proiect tabele , împreună cu employee_project se alăture masă cu employee_id și PROJECT_ID ca chei străine:

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; 

Odată cu crearea bazei de date, următorul pas ar fi pregătirea dependențelor Maven și a configurației Hibernate. Pentru informații despre acest lucru, vă rugăm să consultați articolul despre Ghid pentru Hibernate4 cu Spring

4. Clasele de modele

Clasele model Angajat și Proiect trebuie create cu adnotări JPA:

@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 }

După cum putem vedea, atât clasa Angajați , cât și clasele Proiect se referă una la cealaltă, ceea ce înseamnă că asocierea dintre ele este bidirecțională.

Pentru a mapa o asociație de la mai mulți la mulți, folosim adnotările @ManyToMany , @JoinTable și @JoinColumn . Să le aruncăm o privire mai atentă.

@ManyToMany adnotarea este utilizat în ambele clase pentru a crea relația multe-la-multe dintre entitățile.

Această asociere are două laturi, adică partea proprietară și partea inversă. În exemplul nostru, partea deținătoare este Angajat, astfel încât tabela de asociere este specificată pe partea deținător utilizând adnotarea @JoinTable în clasa Angajați . @JoinTable este folosit pentru a defini tabelul join / link - ul. În acest caz, este Angajat_Proiect.

@JoinColumn adnotarea este folosit pentru a specifica join / care leagă coloana cu tabelul principal. Aici, join coloana este employee_id și PROJECT_ID este inversa se alăture coloana deoarece Proiectul este pe partea inversă a relației.

În clasa Project , atributul mappedBy este utilizat în adnotarea @ManyToMany pentru a indica faptul că colecția angajaților este mapată de colecția de proiecte din partea proprietarului.

5. Executarea

Pentru a vedea adnotarea mai multor la mulți în acțiune, putem scrie următorul test JUnit:

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()); } } // ... }

Putem vedea relația multe-la-multe între cele două entități create în baza de date: a angajatului , proiectul și employee_project tabele cu date eșantion care reprezintă relația.

6. Concluzie

În acest tutorial, am văzut cum să creăm mapări utilizând adnotările multe-la-multe ale Hibernate, care este un omolog mai convenabil în comparație cu crearea fișierelor de mapare XML.

Codul sursă al acestui tutorial poate fi găsit pe GitHub.