streamalism.org

1. Introduktion

Denne hurtige dvalevejledning tager os gennem et eksempel på en en-til-mange kortlægning ved hjælp af JPA-kommentarer, et alternativ til XML.

Vi lærer også, hvad tovejsforhold er, hvordan de kan skabe uoverensstemmelser, og hvordan ideen om ejerskab kan hjælpe.

2. Beskrivelse

Kort fortalt,en-til-mange kortlægning betyder, at en række i en tabel kortlægges til flere rækker i en anden tabel.

Lad os se på følgende diagram over enhedsforhold for at se a en-til-mange forening:

I dette eksempel implementerer vi et vognsystem, hvor vi har en tabel for hver vogn og en anden tabel for hver vare. En vogn kan have mange genstande, så her har vi en en-til-mange kortlægning.

Den måde dette fungerer på databaseniveau er, at vi har en cart_id som en primær nøgle i vogn bord og også en cart_id som en fremmed nøgle i genstande.

Den måde, vi gør det på i kode, er med @OneToMany.

Lad os kortlægge Vogn klasse til Varer objekt på en måde, der afspejler forholdet i databasen:

public class Cart {// ... @OneToMany (mappedBy = "cart") private sæt varer; // ...}

Vi kan også tilføje en henvisning til Vogn i Varer ved brug af @ManyToOne, hvilket gør dette til et tovejsforhold. Tovejs betyder det vi er i stand til at få adgang genstande fra vogne, og også vogne fra genstande.

Det kortlagt af egenskab er det, vi bruger til at fortælle dvale, hvilken variabel vi bruger til at repræsentere moderklassen i vores barneklasse.

Følgende teknologier og biblioteker bruges til at udvikle et eksempel på en dvale-applikation, der implementeres en-til-mange forening:

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

3. Opsætning

3.1. Databaseopsætning

Nedenfor er vores databasescript til Vogn og Varer tabeller. Vi bruger den udenlandske nøglebegrænsning til en-til-mange kortlægning:

Opret TABEL `Indkøbskurv '(` cart_id` int (11) usigneret IKKE NULL AUTO_INCREMENT, PRIMÆR NØGLE (`cart_id`)) MOTOR = InnoDB AUTO_INCREMENT = 5 STANDARD TEGN = utf8; Opret TABEL `Varer` (` id` int (11) usigneret IKKE NULL AUTO_INCREMENT, `cart_id` int (11) unsigned NOT NULL, PRIMARY KEY (` id`), KEY `cart_id` (` cart_id`), CONSTRAINT `items_ibfk_1 `UDENLANDSK KEY (` cart_id`) REFERENCER `Cart` (` cart_id`)) MOTOR = InnoDB AUTO_INCREMENT = 7 STANDARD CHARSET = utf8;

Vores databaseopsætning er klar, så lad os gå videre til at oprette eksempelet Hibernate.

3.2. Maven afhængigheder

Vi tilføjer derefter dvale- og H2-driverafhængigheden til vores pom.xml fil. Den dvaleafhængighed bruger JBoss-logning, og den tilføjes automatisk som transitive afhængigheder:

• Dvaletilstand version 5.2.7 Afsluttende
• H2 driver version 1.4.197

Besøg Maven centrale arkiv for de nyeste versioner af dvale og H2-afhængigheder.

3.3. Dvaletilstandskonfiguration

Her er konfigurationen af ​​dvale:

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

3.4. Dvaletilstand AnnotationUtil Klasse

Med Dvaletilstand AnnotationUtil klasse, vi skal bare henvise til den nye Hibernate-konfigurationsfil:

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

4. Modellerne

Kortlægningsrelaterede konfigurationer udføres ved hjælp af JPA-kommentarer i modelklasserne:

@Entity @Table (name = "CART") offentlig klasse Indkøbskurv {// ... @OneToMany (mappedBy = "cart") private sæt varer; // getters og setters}

Bemærk, at @OneToMany annotation bruges til at definere egenskaben i Varer klasse, der skal bruges til at kortlægge kortlagt af variabel. Derfor har vi en ejendom ved navn “vogn”I Varer klasse:

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

Det er også vigtigt at bemærke, at @ManyToOne kommentar er knyttet til Vogn klasse variabel. @JoinColumn annotation henviser til den kortlagte kolonne.

5. I aktion

I testprogrammet opretter vi en klasse med en vigtigste() metode til at hente dvale-sessionen og gemme modelobjekterne i databasen, der implementerer en-til-mange forening:

sessionFactory = HibernateAnnotationUtil.getSessionFactory (); session = sessionFactory.getCurrentSession (); System.out.println ("Session oprettet"); tx = session.beginTransaction (); session.save (vogn); 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 set i afsnit 2, kan vi specificere en mange-til-en forhold ved hjælp af @ManyToOne kommentar. EN mange-til-en kortlægning betyder, at mange forekomster af denne enhed kortlægges til en forekomst af en anden enhed - mange genstande i en vogn.
Det @ManyToOne kommentar lader os også skabe tovejsforhold. Vi vil dække dette detaljeret i de næste par underafsnit.
6.1. Uoverensstemmelser og ejerskab
Nu, hvis Vogn refereret Varer, men Varer ikke til gengæld reference Vogn, vores forhold ville være ensrettet. Objekterne ville også have en naturlig konsistens.
I vores tilfælde er forholdet dog tovejs, bringe muligheden for inkonsekvens.
Lad os forestille os en situation, hvor en udvikler vil tilføje punkt 1 til vogn og vare2 til vogn2, men laver en fejl, så referencerne mellem vogn2 og vare2 blive inkonsekvent:
Vognkurv1 = ny vogn (); Vognkurv2 = ny vogn (); Varer item1 = nye varer (cart1); Varer item2 = nye varer (cart2); Indstil itemsSet = nyt HashSet (); itemsSet.add (item1); itemsSet.add (item2); cart1.setItems (itemsSet); // forkert!
Som vist ovenfor, vare2 referencer vogn2, der henviser til vogn2 refererer ikke vare2, og det er dårligt.
Hvordan skal dvale gemme vare2 til databasen? Vilje vare2 fremmed nøglehenvisning vogn1 eller vogn2?
Vi løser denne tvetydighed ved hjælp af ideen om en ejerside af forholdet; referencer, der hører til ejersiden, har forrang og gemmes i databasen.
6.2. Varer som den ejende side
Som anført i JPA-specifikationen under afsnit 2.9, det er en god praksis at markere mange-til-en side som ejerside.
Med andre ord, jegtems ville være ejersiden og Vogn den indvendige side, hvilket er nøjagtigt hvad vi gjorde tidligere.
Så hvordan opnåede vi dette?
Ved at inkludere kortlagt af attribut i Vogn klasse markerer vi det som den indvendige side. 
Samtidig kommenterer vi også Varer.vogn felt med @ManyToOne, gør Varer ejersiden.
Vender vi tilbage til vores "inkonsekvens" eksempel, nu ved dvale, at vare2'S reference er vigtigere og vil spare vare2'S henvisning til databasen.
Lad os kontrollere resultatet:
item1 ID = 1, Foreign Key Cart ID = 1 item2 ID = 2, Foreign Key Cart ID = 2
Selvom vogn referencer vare2 i vores uddrag vare2'S henvisning til vogn2 gemmes i databasen.
6.3. Vogn som den ejende side
Det er også muligt at markere en-til-mange side som ejerside, og mange-til-en side som den indvendige side.
Selvom dette ikke er en anbefalet praksis, lad os gå videre og prøve det.
Kodestykket nedenfor viser implementeringen af en-til-mange side som ejerside:
public class ItemsOIO {// ... @ManyToOne @JoinColumn (name = "cart_id", insertable = false, updatable = false) privat CartOIO-vogn; // ..} offentlig klasse CartOIO {// .. @OneToMany @JoinColumn (name = "cart_id") // vi har brug for at duplikere de fysiske oplysninger, private sætelementer; // ..} 
Læg mærke til, hvordan vi fjernede kortlagt af element og indstil mange-til-en @JoinColumn som kan indsættes og kan opdateres til falsk.
Hvis vi kører den samme kode, bliver resultatet det modsatte:
item1 ID = 1, udenlandsk nøglekurv ID = 1 item2 ID = 2, Foreign Key Cart ID = 1
Som vist ovenfor, nu vare2 tilhører vogn.
7. Konklusion
Vi har set, hvor let det er at implementere en-til-mange forhold til Hibernate ORM- og H2-databasen ved hjælp af JPA-kommentarer.
Derudover lærte vi om tovejsforhold og hvordan man implementerer forestillingen om en ejerside.
Kildekoden i denne artikel kan findes på GitHub.