Spring Boot med Hibernate

beskrivning

enkelt uttryckt innebär en-till-många kartläggning att en rad i en tabell mappas till flera rader i en annan tabell.

Låt oss titta på följande entitetsrelationsdiagram för att se en en-till-många-förening:

i det här exemplet implementerar vi ett kundvagnssystem där vi har en tabell för varje kundvagn och en annan tabell för varje objekt. En vagn kan ha många objekt, så här har vi en en-till-många kartläggning.

hur detta fungerar på databasnivå är att vi har en cart_id som primärnyckel i kundvagnstabellen och även en cart_id som en främmande nyckel i objekt.

hur vi gör det i kod är med @OneToMany.

låt oss kartlägga Kundvagnsklassen till objektet på ett sätt som återspeglar förhållandet i databasen:

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

Vi kan också lägga till en referens Till kundvagnen i objekt med @ManyToOne, vilket gör detta till ett dubbelriktat förhållande. Dubbelriktad innebär att vi har tillgång till objekt från vagnar, och även vagnar från objekt.

egenskapen mappedBy är vad vi använder för att berätta för viloläge vilken variabel vi använder för att representera föräldraklassen i vår barnklass.

följande tekniker och bibliotek används för att utveckla ett exempel Hibernate program som implementerar en-till-många association:

• JDK 1.8 eller senare
• Hibernate 5
• Maven 3 eller senare
• H2 databas

Setup

3.1. Database Setup

nedan är vår databas skript för varukorg och objekt tabeller. Vi använder den främmande nyckelbegränsningen för en-till-många kartläggning:

vår databasinställning är klar, så låt oss gå vidare till att skapa Hibernate-exempelprojektet.

3.2. Maven beroenden

vi lägger sedan till Hibernate och H2 drivrutinsberoende till vår pom.xml-fil. Hibernate-beroendet använder JBoss-loggning, och det läggs automatiskt till som transitiva beroenden:

• Hibernate version 5.2.7.Slutlig
• H2 drivrutin version 1.4.197

besök Maven central repository för de senaste versionerna av Hibernate och H2-beroenden.

3, 3. Hibernate konfiguration

här är konfigurationen av Hibernate:

3.4. HibernateAnnotationUtil-klassen

med HibernateAnnotationUtil-klassen behöver vi bara referera till den nya Hibernate-konfigurationsfilen:

modellerna

kartläggningsrelaterade konfigurationer kommer att göras med JPA-anteckningar i modellklasserna:

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

Observera att @OneToMany-anteckningen används för att definiera egenskapen i Objektklass som ska användas för att kartlägga variabeln mappedBy. Det är därför vi har en egenskap som heter ”cart” i Objektklassen:

det är också viktigt att notera att @ManyToOne-anteckningen är associerad med Cart-klassvariabeln. @ JoinColumn annotation refererar till den mappade kolumnen.

i aktion

i testprogrammet skapar vi en klass med en huvudmetod() för att få Hibernate-sessionen och spara modellobjekten i databasen som implementerar en-till-många-föreningen:

detta är resultatet av vårt testprogram:

@ManyToOne-anteckningen

som vi har sett i avsnitt 2 kan vi specificera en många-till-ett-relation genom att använda @manytoone-anteckningen. En många-till-en – kartläggning innebär att många instanser av denna enhet mappas till en instans av en annan enhet-många artiklar i en kundvagn.

@ManyToOne-anteckningen låter oss också skapa Dubbelriktade relationer. Vi kommer att täcka detta i detalj i de närmaste underavsnitten.

6, 1. Inkonsekvenser och ägande

Nu, om varukorgen refererade objekt, men objekt inte i sin tur referensvagn, skulle vårt förhållande vara enkelriktat. Föremålen skulle också ha en naturlig konsistens.

i vårt fall är förhållandet dubbelriktat, vilket medför möjligheten till inkonsekvens.

låt oss föreställa oss en situation där en utvecklare vill lägga till item1 i kundvagnen och item2 i cart2, men gör ett misstag så att referenserna mellan cart2 och item2 blir inkonsekventa:

som visas ovan refererar item2 cart2, medan cart2 inte refererar item2, och det är dåligt.

hur ska Hibernate spara item2 i databasen? Kommer item2 utländsk nyckel referens cart1 eller cart2?

vi löser denna tvetydighet med hjälp av tanken på en ägande sida av förhållandet; referenser som tillhör ägandesidan har företräde och sparas i databasen.

6, 2. Objekt som Ägandesidan

som anges i JPA-specifikationen under avsnitt 2.9 är det en bra praxis att markera många till en sida som ägandesidan.

med andra ord, objekt skulle vara ägande sidan och vagn den inversa sidan, vilket är precis vad vi gjorde tidigare.

så hur uppnådde vi detta?

genom att inkludera mappedby-attributet i Cart-klassen markerar vi det som den omvända sidan.

samtidigt kommenterar vi också objekten.kundvagn fält med @ManyToOne, vilket gör objekt ägande sidan.

gå tillbaka till vårt exempel” inkonsekvens”, nu vet Hibernate att item2s referens är viktigare och kommer att spara item2s referens till databasen.

låt oss kontrollera resultatet:

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

även om varukorgen refererar till item2 i vårt utdrag sparas item2s referens till cart2 i databasen.

6, 3. Kundvagn som ägande sida

det är också möjligt att markera en-till-många sida som ägande sida, och många-till-en sida som den inversa sidan.

Även om detta inte är en rekommenderad övning, låt oss gå vidare och prova.

kodavsnittet nedan visar implementeringen av en-till-många-sida som ägande sida:

Lägg märke till hur vi tog bort mappedBy-elementet och ställ in många-till-en @JoinColumn som infogbar och uppdaterbar till false.

om vi kör samma kod blir resultatet motsatt:

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

som visas ovan, tillhör nu item2 till cart.

slutsats

Vi har sett hur lätt det är att implementera en-till-många-förhållandet med Hibernate ORM och H2-databasen med JPA-anteckningar.

dessutom lärde vi oss om Dubbelriktade relationer och hur man implementerar begreppet en ägande sida.