Tags:    grails hjemmeside database groovy Denne artikel er en efterfølger til artiklen “Introduktion til Grails” som kan læses her på udvikleren. Har du ikke allerede læst den, anbefales det er starte med denne artikel. Denne artikel vil gå mere i dybden med modellen (domain). Det er denne del hvor du fortæller hvad der skal gemmes i din database.

I denne artikel vil vi se på:

1. Hvorledes du kan bruge din foretrukne database (såsom MySQL).


2. Hvorledes du kan sætte begrænsninger på din model der sikre at den kun tager imod fornuftigt indhold.


3. Hvordan du laver one-to-one, one-to-many og many-to-many relationer imellem dine tabeller.

1. Ændre database

Som standart benytter Grails sig af databasen HSQLDB. Databasen er en open-source letvægtsdatabase lavet i Java. Databasen er populær, men på ingen måde i samme grad som MySQL, Oracle og så videre. Er du vandt til at arbejde med en af disse databaser kan du med stor fornuft vælge at benytte dig af den. Dette kræver naturligvis at du har en anden database oppe at køre (hvilket vi ikke vil se på her)
Grails benytter sig af JDBC (Java DataBase Connectivity) til at forbinde sig med databasen. Og heldigvis er JDBC meget populær og der findes derfor JDBC drivers for alle databaser med respekt for sig selv. Derfor med stor sikkerhed også den du benytter.

Konfigurationen af databasen foregår via filen DataSource.groovy (filmappe: grails-app/conf).



DataSource.groovy ser som standart således ud:

 dataSource {
     pooled = true
     driverClassName = "org.hsqldb.jdbcDriver"
     username = "sa"
     password = ""
 }
 hibernate {
     cache.use_second_level_cache = true
     cache.use_query_cache = true
     cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'
 }
 // environment specific settings
 environments {
     development {
         dataSource {
             dbCreate = "create-drop" // one of 'create', 'create-drop','update'
             url = "jdbc:hsqldb:mem:devDB"
         }
     }
     test {
         dataSource {
             dbCreate = "update"
             url = "jdbc:hsqldb:mem:testDb"
         }
     }
     production {
         dataSource {
             dbCreate = "update"
             url = "jdbc:hsqldb:file:prodDb;shutdown=true"
         }
     }
 }

Forståelse af DataSource.groovy
Et Grails projekt kan køre i tre forskellige miljøer (environments): Development, Test og Production. Development er det miljø du bør køre når du udvikler siden. Test er miljøet når du ønsker at teste dit system. Og endelig er production det miljø du bruger når din hjemmeside skal skal køre på nettet (i produktion). Det smarte ved dette er at du kan have brug for forskellige indstillinger i de forskellige miljøer.
Nå du køre grails koden grails run-app køre du dit projekt i development-miljøet idet det er standart. Ønsker du at køre dit projekt i andre miljøer kan du bruge følgende koder:

 grails prod run-app  //For production
 grails test run-app  //For test
 grails dev run-app  //For development

At have forskellige indstillinger gælder blandt andet også for din database. Derfor ser du at der i din DataSource.groovy står koden:

 environments {
     development {
         dataSource {
             ...
         }
     }
     test {
         dataSource {
         ...
         }
     }
     production {
         dataSource {
         ...
         }
     }
 }

Lad os se hvad indstillingerne gør:

dbCreate: Bruges til at vælge hvorvidt den skal lave en ny database, hver gang serveren startes, eller om den skal vedligeholde den allerede eksisterende.
I development-mijøet, som vi som standart benytter, vil vi opdage at hver gang serveren genstartes er alle instanser indsat fjernet. Dette skyldes den er sat til create-drop. Her stømmes og derefter genlaves database tabellerne hver gang.
Alternativt kan indstillingen update også benyttes. Her bliver databasen altid vedligeholdt, og aldrig tømt. Dette er velegnet til production.

url: Er JDBC url-adressen til databasen.


Ændre koden så anden database benyttes

1. Hent den ConnectJ driveren der høre til din database. Den kan findes på databasens producents hjemmeside. MySQL's driver findes her: http://dev.mysql.com/downloads/connector/j/5.0.html


2. I den komprimerede-mappe findes en jar-fil som du placerer i projektets mappe lib.
   


3. Ændre DataSource.groovy til at benytte din ønskede database.

For at benytte MySQL benyttes følgende kode:

 dbCreate = "update"
 url = "jdbc:mysql://localhost/Projektnavn"
 driverClassName = "com.mysql.jdbc.Driver"
 username = "root"
 password = ""

Url: Som tidligere nævnt er url adressen på din database.
DriverClassName: Her skrives klassenavnet på driveren. Dette burde gerne kunne findes på databasens hjemmeside.
Username: Brugernavn til databasen
Password: Dit password til databasen

Den samlede kode kommer til at se således ud:

 dataSource {
     pooled = true
     driverClassName = "org.hsqldb.jdbcDriver"
     username = "sa"
     password = ""
 }
 hibernate {
     cache.use_second_level_cache = true
     cache.use_query_cache = true
     cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'
 }
 // environment specific settings
 environments {
     development {
         dataSource {
             dbCreate = "update"
             url = "jdbc:mysql://localhost/Shafhdk"
             driverClassName = "com.mysql.jdbc.Driver"
             username = "root"
             password = ""
         }
     }
     test {
         dataSource {
             dbCreate = "update"
             url = "jdbc:hsqldb:mem:testDb"
         }
     }
     production {
         dataSource {
             dbCreate = "update"
             url = "jdbc:hsqldb:file:prodDb;shutdown=true"
         }
     }
 }

Bemærk at MySQL også kan sættes til for de andre miljøer.



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