verder lezen:

omschrijving

simpel gezegd betekent een-op-veel toewijzing dat een rij in een tabel wordt toegewezen aan meerdere rijen in een andere tabel.

laten we eens kijken naar het volgende entity relationship diagram om een één-op-veel associatie te zien:

in dit voorbeeld zullen we een cart systeem implementeren waarin we een tabel hebben voor elke cart en een andere tabel voor elk item. Een kar kan veel items hebben, dus hier hebben we een één-op-veel mapping.

de manier waarop dit werkt op databaseniveau is dat we een cart_id als primaire sleutel in de cart tabel hebben en ook een cart_id als een buitenlandse sleutel in items.

de manier waarop we het in code doen is met @OneToMany.

laten we de Cart-klasse toewijzen aan het object Items op een manier die de relatie in de database weergeeft:

public class Cart { //... @OneToMany(mappedBy="cart") private Set<Items> items; //...}

We kunnen ook een verwijzing naar Cart toevoegen in Items met behulp van @ManyToOne, waardoor dit een bidirectionele relatie is. Bidirectionele betekent dat we in staat zijn om toegang te krijgen tot items van karren, en ook karren van items.

de eigenschap mapped by is wat we gebruiken om Hibernate te vertellen welke variabele we gebruiken om de ouderklasse in onze kindklasse te vertegenwoordigen.

de volgende technologieën en bibliotheken worden gebruikt om een sample Hibernate applicatie te ontwikkelen die één-op-veel associatie implementeert:

• JDK 1.8 of hoger
• Hibernate 5
• Maven 3 of hoger
• H2 database

Setup

3.1. Database Setup

hieronder staat ons database script voor Cart en Items tabellen. We gebruiken de FOREIGN key constraint voor één-op-veel mapping:

onze database setup is klaar, dus laten we doorgaan met het maken van het Hibernate voorbeeld project.

3.2. Maven afhankelijkheden

We zullen dan de Hibernate en H2 driver afhankelijkheden toevoegen aan onze pom.xml-bestand. De Hibernate afhankelijkheid maakt gebruik van JBoss logging, en het wordt automatisch toegevoegd als transitieve afhankelijkheden:

• Hibernate versie 5.2.7.Final
• H2 driver Versie 1.4.197

bezoek de Maven central repository voor de laatste versies van Hibernate en de H2 afhankelijkheden.

3.3. Hibernate configuratie

Hier is de configuratie van Hibernate:

3.4. HibernateAnnotationUtil Class

met de HibernateAnnotationUtil class hoeven we alleen maar te verwijzen naar het nieuwe Hibernateconfiguratiebestand:

de modellen

de mapping gerelateerde configuraties worden gedaan met behulp van JPA-annotaties in de modelklassen:

@Entity@Table(name="CART")public class Cart { //... @OneToMany(mappedBy="cart") private Set<Items> items; // getters and setters}

houd er rekening mee dat de @OneToMany annotatie wordt gebruikt om de eigenschap te definiëren in de Itemklasse die zal worden gebruikt om de map toe te wijzen door de variabele. Daarom hebben we een eigenschap genaamd “cart” in de Items class:

het is ook belangrijk op te merken dat de @ManyToOne annotatie geassocieerd is met de Cart class variabele. @ JoinColumn annotatie verwijst naar de toegewezen kolom.

in Actie

In het testprogramma maken we een klasse met een main() methode voor het verkrijgen van de Hibernate sessie, en het opslaan van de modelobjecten in de database implementatie van de één-tot-veel associatie:

Dit is de uitvoer van ons testprogramma:

de @ManyToOne annotatie

zoals we hebben gezien in Paragraaf 2, we kan een many-to-one relatie specificeren met behulp van de @manytoone annotatie. Een many-to-one mapping betekent dat veel instanties van deze entiteit worden toegewezen aan een instantie van een andere entiteit – veel items in één winkelwagen.

De @ManyToOne annotatie laat ons ook bidirectionele relaties creëren. We zullen dit in detail behandelen in de volgende paar subsecties.

6.1. Inconsistenties en eigendom

nu, als Cart verwezen naar Items, Maar Items niet op hun beurt referentie Cart, onze relatie zou unidirectioneel zijn. De objecten zouden ook een natuurlijke consistentie hebben.

in ons geval is de relatie echter bidirectioneel, waardoor de mogelijkheid van inconsistentie ontstaat.

stel je een situatie voor waarin een ontwikkelaar item1 aan cart en item2 aan cart2 wil toevoegen, maar een fout maakt zodat de verwijzingen tussen cart2 en item2 inconsistent worden:

zoals hierboven getoond, verwijst item2 naar cart2, terwijl cart2 niet naar item2 verwijst, en dat is slecht.

Hoe moet item2 in de slaapstand worden opgeslagen in de database? Zal item2 foreign key reference cart1 of cart2?

we lossen deze dubbelzinnigheid op door gebruik te maken van het idee van een eigenaar kant van de relatie; referenties die behoren tot de eigenaar kant hebben voorrang en worden opgeslagen in de database.

6.2. Items als de Eigendomszijde

zoals vermeld in de JPA-specificatie onder paragraaf 2.9, is het een goede praktijk om veel-op-één-zijde als de eigendomszijde aan te merken.

met andere woorden, Items zouden de eigenaar kant en Cart de inverse kant, dat is precies wat we eerder deden.

dus hoe hebben we dit bereikt?

door het attribuut mapped by in de Cart class op te nemen, markeren we het als de inverse zijde.

tegelijkertijd annoteren we ook de Items.cart veld met @ManyToOne, het maken van Items de eigenaar kant.

teruggaand naar ons” inconsistentie “voorbeeld, nu Weet Hibernate dat de referentie van item2 belangrijker is en zal item2′ s referentie naar de database opslaan.

laten we het resultaat controleren:

item1 ID=1, Foreign Key Cart ID=1item2 ID=2, Foreign Key Cart ID=2

hoewel cart verwijst naar item2 in ons fragment, wordt item2 ‘ s verwijzing naar cart2 opgeslagen in de database.

6.3. Cart als de eigenaar zijde

Het is ook mogelijk om de één-op-veel zijde als de eigenaar zijde te markeren, en veel-op-één zijde als de inverse zijde.

hoewel dit geen aanbevolen oefening is, laten we het eens proberen.

het codefragment hieronder toont de implementatie van één-op-veel kant als de eigenaar kant:

merk op hoe we het toegewezen element hebben verwijderd en de veel-op-één @JoinColumn hebben ingesteld als invoegbaar en bij te werken naar false.

als we dezelfde code draaien, zal het resultaat het tegenovergestelde zijn:

item1 ID=1, Foreign Key Cart ID=1item2 ID=2, Foreign Key Cart ID=1

zoals hierboven getoond, behoort nu item2 tot cart.

conclusie

We hebben gezien hoe eenvoudig het is om de een-op-veel relatie met de Hibernate ORM en H2 database te implementeren met behulp van JPA annotaties.

daarnaast leerden we over bidirectionele relaties en hoe we de notie van een eigenaar kant kunnen implementeren.