streamalism.org

1. Introduksjon

Denne raske Hibernate-opplæringen tar oss gjennom et eksempel på en en-til-mange kartlegging ved hjelp av JPA-merknader, et alternativ til XML.

Vi lærer også hva toveis forhold er, hvordan de kan skape uoverensstemmelser, og hvordan ideen om eierskap kan hjelpe.

2. Beskrivelse

For å si det enkelt,en-til-mange kartlegging betyr at en rad i en tabell er kartlagt til flere rader i en annen tabell.

La oss se på følgende diagram for enhetsforhold for å se a en-til-mange assosiasjon:

For dette eksemplet implementerer vi et vognsystem der vi har en tabell for hver vogn og en annen tabell for hvert element. En vogn kan ha mange gjenstander, så her har vi en en-til-mange kartlegging.

Slik dette fungerer på databasenivå har vi en cart_id som hovednøkkel i vogn bord og også en cart_id som en fremmed nøkkel i gjenstander.

Måten vi gjør det på kode er med @OneToMany.

La oss kartlegge Handlevogn klasse til Varer objekt på en måte som gjenspeiler forholdet i databasen:

offentlig klasse Handlevogn {// ... @OneToMany (mappedBy = "cart") private Settelementer; // ...}

Vi kan også legge til en referanse til Handlevogn i Varer ved hjelp av @ManyToOne, gjør dette til et toveis forhold. Toveis betyr det vi har tilgang til gjenstander fra vogner, og også vogner fra gjenstander.

De kartlagt av egenskap er det vi bruker for å fortelle dvalemodus hvilken variabel vi bruker for å representere foreldreklassen i barneklassen vår.

Følgende teknologier og biblioteker brukes for å utvikle en prøve Hibernate-applikasjon som implementeres en-til-mange assosiasjon:

• JDK 1.8 eller senere
• Dvalemodus 5
• Maven 3 eller senere
• H2-database

3. Oppsett

3.1. Databaseoppsett

Nedenfor er vårt databasescript for Handlevogn og Varer bord. Vi bruker begrensningen for utenlandsk nøkkel for en-til-mange kartlegging:

OPPRETT TABELL `Handlevogn` (` cart_id` int (11) usignert IKKE NULL AUTO_INCREMENT, PRIMÆR NØKKEL (`cart_id`)) MOTOR = InnoDB AUTO_INCREMENT = 5 STANDARDTEGN = utf8; OPPRETT TABELL `Items` (` id` int (11) unsigned NOT NULL AUTO_INCREMENT, `cart_id` int (11) unsigned NOT NULL, PRIMARY KEY (` id`), KEY `cart_id` (` cart_id`), CONSTRAINT `items_ibfk_1 `UTENLANDSK Nøkkel (` cart_id`) REFERANSER `Cart` (` cart_id`)) MOTOR = InnoDB AUTO_INCREMENT = 7 STANDARD CHARSET = utf8;

Databaseoppsettet vårt er klart, så la oss gå videre til å lage Hibernate-eksempelprosjektet.

3.2. Maven avhengigheter

Deretter legger vi avhengig av dvalemodus og H2-driver til vår pom.xml fil. Dvalemodusavhengigheten bruker JBoss-logging, og den blir automatisk lagt til som transitive avhengigheter:

• Dvalemodus versjon 5.2.7 Endelig
• H2 driverversjon 1.4.197

Besøk Maven sentrale arkiv for de nyeste versjonene av Hibernate og H2-avhengighet.

3.3. Dvalemodus-konfigurasjon

Her er konfigurasjonen av dvalemodus:

  org.h2.Driver jdbc: h2: mem: spring_hibernate_one_to_many sa org.hibernate.dialect.H2Dialect thread true 

3.4. HibernateAnnotationUtil Klasse

Med HibernateAnnotationUtil klasse, trenger vi bare å referere til den nye dvalemodus-konfigurasjonsfilen:

privat statisk SessionFactory sessionFactory; private SessionFactory buildSessionFactory () {ServiceRegistry serviceRegistry = ny StandardServiceRegistryBuilder (). configure ("hibernate-annotation.cfg.xml"). build (); Metadata metadata = nye MetadataSources (serviceRegistry) .getMetadataBuilder (). Build (); SessionFactory sessionFactory = metadata.getSessionFactoryBuilder (). Build (); returøktFabrikk; } offentlig SessionFactory getSessionFactory () {if (sessionFactory == null) sessionFactory = buildSessionFactory (); returøktFabrikk; }

4. Modellene

Kartleggingsrelaterte konfigurasjoner gjøres ved hjelp av JPA-merknader i modellklassene:

@Entity @Table (name = "CART") offentlig klasse Handlekurv {// ... @OneToMany (mappedBy = "cart") private Settelementer; // getters og setters}

Vær oppmerksom på at @OneToMany kommentar brukes til å definere egenskapen i Varer klasse som skal brukes til å kartlegge kartlagt av variabel. Derfor har vi en eiendom som heter “vogn”I Varer klasse:

@Entity @Table (name = "ITEMS") public class Items {// ... @ManyToOne @JoinColumn (name = "cart_id", nullable = false) private handlevogn; offentlige gjenstander () {} // getters and setters} 

Det er også viktig å merke seg at @ManyToOne merknader er assosiert med Handlevogn klasse variabel. @JoinColumn merknader refererer til den tilordnede kolonnen.

5. I aksjon

I testprogrammet lager vi en klasse med en hoved-() metode for å få dvalemodus, og lagre modellobjektene i databasen ved implementering av en-til-mange assosiasjon:

sessionFactory = HibernateAnnotationUtil.getSessionFactory (); økt = sessionFactory.getCurrentSession (); System.out.println ("Session opprettet"); tx = session.beginTransaction (); session.save (cart); session.save (item1); session.save (item2); tx.commit (); System.out.println ("Cartitem1, Foreign Key Cartitem2, Foreign Key Cartmany-to-one">6. Den @ManyToOne Kommentar
Som vi har sett i avsnitt 2, kan vi spesifisere a mange-mot-en forhold ved å bruke @ManyToOne kommentar. EN mange-til-en kartlegging betyr at mange forekomster av denne enheten er kartlagt til en forekomst av en annen enhet - mange varer i en vogn.
De @ManyToOne kommentar lar oss også lage toveis forhold. Vi vil dekke dette i detalj i de neste par delene.
6.1. Uoverensstemmelser og eierskap
Nå, hvis Handlevogn referert Varer, men Varer gjorde ikke i sin tur referanse Handlevogn, forholdet vårt ville være ensrettet. Objektene vil også ha en naturlig konsistens.
I vårt tilfelle er forholdet toveis, å bringe inn muligheten for inkonsekvens.
La oss forestille oss en situasjon der en utvikler ønsker å legge til element1 til vogn og vare2 til vogn2, men gjør en feil slik at referansene mellom vogn2 og vare2 bli inkonsekvent:
Handlevogn cart1 = ny handlevogn (); Handlevogn cart2 = ny handlevogn (); Varer item1 = nye Items (cart1); Varer item2 = nye Items (cart2); Set itemsSet = new HashSet (); itemsSet.add (item1); itemsSet.add (item2); cart1.setItems (itemsSet); // feil!
Som vist ovenfor, vare2 referanser cart2, mens vogn2 refererer ikke item2, og det er ille.
Hvordan skal dvalemodus lagre vare2 til databasen? Vil vare2 utenlandsk nøkkelreferanse vogn1 eller vogn2?
Vi løser denne tvetydigheten ved å bruke ideen om en eierside av forholdet; referanser som tilhører eiersiden har forrang og lagres i databasen.
6.2. Varer som eiesiden
Som det fremgår av JPA-spesifikasjonen under avsnitt 2.9, det er en god praksis å merke mange-til-en side som eiersiden.
Med andre ord, Jegtems ville være eiersiden og Handlevogn den omvendte siden, som er akkurat det vi gjorde tidligere.
Så hvordan oppnådde vi dette?
Ved å inkludere kartlagt av attributt i Handlevogn klasse, markerer vi det som den omvendte siden. 
Samtidig kommenterer vi også Varer.vogn felt med @ManyToOne, lager Varer eiersiden.
Når vi går tilbake til vårt "inkonsekvens" -eksempel, vet Hibernate at vare2’S referanse er viktigere og vil spare vare2’Henvisning til databasen.
La oss sjekke resultatet:
item1 ID = 1, Foreign Key Cart ID = 1 item2 ID = 2, Foreign Key Cart ID = 2
Selv om vogn referanser vare2 i utdraget vårt, vare2’S referanse til vogn2 lagres i databasen.
6.3. Handlevogn som eiesiden
Det er også mulig å merke en-til-mange side som eiersiden, og mange-mot-en side som omvendt side.
Selv om dette ikke er en anbefalt praksis, la oss prøve.
Kodebiten nedenfor viser implementeringen av en-til-mange side som eiersiden:
offentlig klasse ItemsOIO {// ... @ManyToOne @JoinColumn (name = "cart_id", insertable = false, updatable = false) privat CartOIO-handlevogn; // ..} offentlig klasse CartOIO {// .. @OneToMany @JoinColumn (name = "cart_id") // vi trenger å duplisere den fysiske informasjonen private settelementer; // ..} 
Legg merke til hvordan vi fjernet kartlagt av element og sett inn mange-til-en @JoinColumn som kan settes inn og kan oppdateres til falsk.
Hvis vi kjører den samme koden, blir resultatet det motsatte:
item1 ID = 1, Foreign Key Cart ID = 1 item2 ID = 2, Foreign Key Cart ID = 1
Som vist ovenfor, nå vare2 tilhører vogn.
7. Konklusjon
Vi har sett hvor enkelt det er å implementere en-til-mange forhold til dvalemodus ORM og H2-databasen ved hjelp av JPA-merknader.
I tillegg lærte vi om toveis forhold og hvordan vi kan implementere forestillingen om en eierside.
Kildekoden i denne artikkelen finner du på GitHub.