Hibernate Many to Many Annotation Tutorial

1. Inleiding

In deze korte zelfstudie bekijken we snel hoe de @Veel te veel annotatie kan worden gebruikt voor het specificeren van dit type relaties in Hibernate.

2. Een typisch voorbeeld

Laten we beginnen met een eenvoudig diagram voor entiteitsrelaties, dat de veel-op-veel-associatie tussen twee entiteiten laat zien werknemer en project:

In dit scenario kan elk gegeven werknemer kan worden toegewezen aan meerdere projecten en een project kan meerdere werknemers hebben die ervoor werken, wat leidt tot een veel-op-veel-associatie tussen de twee.

We hebben een werknemer tafel met employee_id als primaire sleutel en een project tafel met project_id als de primaire sleutel. Een gezamenlijke tafel werknemer_project is hier nodig om beide zijden te verbinden.

3. Database-instellingen

Laten we aannemen dat we al een database hebben gemaakt met de naam spring_hibernate_many_to_many.

We moeten ook het werknemer en project tabellen samen met de werknemer_project aanschuiven tafel met employee_id en project_id als externe sleutels:

TABEL MAKEN `werknemer` (` werknemer_id` int (11) NOT NULL AUTO_INCREMENT, `voornaam` varchar (50) STANDAARD NULL,` achternaam` varchar (50) STANDAARD NULL, PRIMAIRE SLEUTEL (`werknemer_id`)) ENGINE = InnoDB AUTO_INCREMENT = 17 STANDAARD CHARSET = utf8; CREATE TABLE `project` (` project_id` int (11) NOT NULL AUTO_INCREMENT, `title` varchar (50) STANDAARD NULL, PRIMAIRE SLEUTEL (` project_id`)) ENGINE = InnoDB AUTO_INCREMENT = 18 STANDAARD 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`), BEPERKING` werknemer_project_ibfk_1` BUITENLANDSE SLEUTEL (`werknemer_id`) REFERENTIES` werknemer` (`werknemer_id`), CONSTRAINT` werknemer_project_ibfk_2` VREEMDE SLEUTEL (`project_id`) REFERENTIES` project` (`project_id`)) ENGINE = InnoDB STANDAARD CHARSET = utf; 

Nu de database is opgezet, is de volgende stap de voorbereiding van de Maven-afhankelijkheden en de Hibernate-configuratie. Voor informatie hierover verwijzen wij u naar het artikel over Guide to Hibernate4 with Spring

4. De modelklassen

De modelklassen Werknemer en Project moeten worden gemaakt met JPA-annotaties:

@Entity @Table (name = "Employee") openbare klasse Medewerker {// ... @ManyToMany (cascade = {CascadeType.ALL}) @JoinTable (naam = "Employee_Project", joinColumns = {@JoinColumn (name = "employee_id) ")}, inverseJoinColumns = {@JoinColumn (name =" project_id ")}) Set projects = nieuwe HashSet (); // standaard constructor / getters / setters}
@Entity @Table (naam = "Project") openbare klasse Project {// ... @ManyToMany (mappedBy = "projecten") privé Stel werknemers = nieuwe HashSet (); // standard constructors / getters / setters}

Zoals we kunnen zien, beide Werknemer klasse en Project klassen verwijzen naar elkaar, wat betekent dat de associatie tussen hen bidirectioneel is.

Om een ​​veel-op-veel-associatie in kaart te brengen, gebruiken we de @Veel te veel, @JoinTable en @JoinColumn annotaties. Laten we ze eens nader bekijken.

De @Veel te veel annotatie wordt in beide klassen gebruikt om de veel-op-veel-relatie tussen de entiteiten te creëren.

Deze associatie heeft twee kanten, namelijk de bezitskant en de omgekeerde kant. In ons voorbeeld is de bezitterige kant Werknemer dus de join-tafel wordt gespecificeerd aan de kant van de eigenaar door de @JoinTable annotatie in Werknemer klasse. De @JoinTable wordt gebruikt om de join / link-tabel te definiëren. In dit geval is het Employee_Project.

De @JoinColumn annotatie wordt gebruikt om de kolom voor samenvoegen / koppelen met de hoofdtabel te specificeren. Hier is de join-kolom employee_id en project_id is de inverse join-kolom sinds Project is aan de omgekeerde kant van de relatie.

In de Project klasse, de mappedBy attribuut wordt gebruikt in de @Veel te veel annotatie om aan te geven dat de medewerkers collectie wordt in kaart gebracht door de projecten verzameling van de eigenaarszijde.

5. Uitvoering

Om de veel-op-veel-annotatie in actie te zien, kunnen we de volgende JUnit-test schrijven:

openbare klasse HibernateManyToManyAnnotationMainIntegrationTest {privé statische SessionFactory sessionFactory; privé sessie sessie; // ... @Test openbare leegte gegevenData_whenInsert_thenCreatesMtoMrelationship () {String [] employeeData = {"Peter Oven", "Allan Norman"}; String [] projectData = {"IT-project", "Netwerkproject"}; Set projects = new HashSet (); voor (String proj: projectData) {projects.add (nieuw project (proj)); } voor (String emp: employeeData) {Werknemer werknemer = nieuwe werknemer (emp.split ("") [0], emp.split ("") [1]); assertEquals (0, employee.getProjects (). size ()); employee.setProjects (projecten); session.persist (medewerker); assertNotNull (werknemer); }} @Test openbare ongeldige gegevenSession_whenRead_thenReturnsMtoMdata () {@SuppressWarnings ("unchecked") Lijst employeeList = session.createQuery ("VAN werknemer") .list (); assertNotNull (employeeList); voor (Werknemer werknemer: employeeList) {assertNotNull (employee.getProjects ()); }} // ...}

We kunnen de veel-op-veel-relatie zien tussen de twee entiteiten die in de database zijn gemaakt: het werknemer, project, en werknemer_project tabellen met voorbeeldgegevens die de relatie vertegenwoordigen.

6. Conclusie

In deze zelfstudie hebben we gezien hoe u toewijzingen kunt maken met behulp van de veel-op-veel-annotaties van Hibernate, wat een handigere tegenhanger is in vergelijking met het maken van XML-toewijzingsbestanden.

De broncode van deze tutorial is te vinden op GitHub.