Tags:    grails hjemmeside database groovy

Domain relationer

På større sider er det atypisk at domænerne alle er uafhængige af hinanden. Ofte har de relationer af hinanden. Dette varierer naturligvis afhængig af hvad din domæner repræsenterer. Der findes tre typer af relationer: one-to-one, one-to-many, many-to-many. Alle disser understøtter Grails, og gør lettet meget lettere for os.

Den simples relation er one-to-one:

One-to-one relation
Et eksempel på sådan en relation kan være to klasser. En der repræsentere en mand og en der repræsenterer en pige:
Ved partnerskab kan der være en relation imellem manden og damen. Og da vi i denne model ikke tillader manden eller kvinden af have flere partnere, kan vi med fornuft repræsenterer dette som en one-to-one relation.

Metoden at kode dette er logisk og fuldstændig som forventet:

 class Pige {
     Mand partner
 }
 
 class Mand {
     Pige partner
 }

Dette ligner hvad vi kender, og vi beskæftiger os derfor ikke yderligere med dette. Hvis det ønsket kan man naturligvis også lade relationen kun gå den ene vej.

I mange af situationerne har man også et forhold hvor det ene objekt er ejer af den anden Havde manden i eksemplet ovenfor en hund, har man sådan en relation. I sådan et tilfælde kan man benytte den statiske property belongsTo:

 class Hund {
     static belongsTo = Mand
 }

eller ved relationer begge veje:

 class Mand {
     Pige partner
     Hund hund
 }
 
 class Hund {
     static belongsTo = [mand:Mand]
 }

Her er ”[mand:Mand]” et map, hvor ”mand” er nøglen. Det smarte ved sådan en relation er at slettes ejer-objektet så slettes også alle de objekter "høre til" det objekt. I dette eksempel vil hunden altså også blive slettet, hvis man vælger at slette manden.



One-to-many relation
Denne type af relationer bruges, som navnet siger, i situationer hvor den ene relation har forbindelser til mange andre objekter, kun har en pointer tilbage den den. Et eksempel på dette kan være et domæne som repræsenterer en cd og et domæne som repræsenterer en sange:
Et album indeholder mange sange, men en sang findes kun på et album. Derfor kan en one-to-many relation med fornuft benyttes her.

Koden til relationen i koden vil se således ud:

 class Song {
     String title
     Album Album
 }
 
 class Album {
     String title
     static hasMany = [songs:Song]
 }

Genereres et view nu vil vi bemærke at man nu kan vælge et album en sang høre til, når vi opretter en sang:



One-to-many
På næsten samme måde kan du lave en many-to-many relation. Et eksempel på sådan en relation vil forekomme imellem lærere og elever på en skole. Dette skyldes at en elev kan have mere end en lære, og at en lære tilsvarende ofte har mere end en elev:

 class Teacher {
     static hasMany = [students:Student]
 
 }
 class Student {
     static belongsTo = [teachers:Teacher]
 }

Bemærk at der også her kræves af domænerne tilhører en anden (belongsTo). Dette er der brug for når Grails laver mapping (dvs læser og gemmer fra databasen).

Afslutning

Vi har nu i denne artikel gået nærmere i dybden med hvorledes du opbygger din model. Som altid skal det dog siges at dette kun er en artikel, og at der utallige urørte emner inden for modellen, som jeg ikke har valgt at berører. Er du interesseret i at vide mere, kan det derfor abefagles at læse videre på egen hånd.

Hvis alt går vel vil der snart komme en del 3 som vil gå i dybden ved controlleren. Så stay tuned .

Jeg håber artiklen har kunnet hjælpe. Held og lykke

Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X