Het open source framework Grails

Hoewel Java nog steeds een goede ontwikkelomgeving is voor webgebaseerde kritische enterprise applicaties is er nu een open source framework voor agile web development met Groovy en Java. In dit artikel ‘Grails – The Search is over’ wordt nader uitleg gegeven over dit open source framework.

In deel 1 van dit artikel hebben we een introductie gegeven van Grails, we gaan nu verder in op de Grails omgeving.

Inhoud en structuur van een Grails applicatie

Bij het creëren van een webapplicatie creëert Grails automatisch de projectstructuur en standaard aanwezige configuratiebestanden. Het COC principe (Convention over Configuration) wordt hierbij gebruikt om het project conform bewezen best-practices in de Java EE community in te richten. Er wordt  niets meer expliciet geconfigureerd maar alles wordt conform conventie voor je ingericht. Je dwingt hiermee af dat je volgens vaste standaarden werkt en dat je ook met een goede standaard werkt. Naast het verbeteren van de standaard verhoogt dit ook productiviteit.

Development

“Develop in development, test in test en produce in production” is één van de vele uitspraken binnen de Java EE community. In de praktijk zijn er vaak integratie-issues tussen de development-, test- en productie-omgeving. Dit ontstaat meestal doordat er (te) veel tijd moet worden gestoken in het beheer van deze verschillende omgevingen. Met Grails wordt dit een stuk makkelijker gemaakt. Grails onderhoudt tijdens run-time de verschillende databases van de omgevingen waardoor deze altijd identiek aan elkaar zijn.

Model-view-controller

Grails maakt de development-mode aanzienlijk sneller omdat veranderingen aan alle classes direct worden doorgevoerd in de database. Er hoeft hiervoor dus niet een build script te worden uitgevoerd. Meestal is het opslaan van de wijzigingen in je domein class voldoende; een enkele keer moet de developmentserver (keuze tussen Jetty of Tomcat) worden herstart. Een dergelijke herstart duurt maximaal 20 seconden. Hiermee lost Grails één van de grootste ergernissen van Java EE development op. Volledige deployment-processsen zijn tijdens ontwikkeling niet meer noodzakelijk.

GORM

Hoewel de wetenschappers al enige tijd bezig zijn met een zogenaamde “objectgeoriënteerde” database, zitten we voorlopig nog wel vast aan de relationele databases en daardoor aan de “mapping impedance mismatch” tussen objectoriëntatie binnen Java en het persisteren naar een relationele database als MySQL, Oracle of DB2. Opslag naar een relationele database staat eigenlijk in het centrum van elke domain-driven applicatie. Grails gebruikt hiervoor GORM:  Grails Object Relational Mapping. GORM zorgt ervoor dat de eigenschappen van een domein object automatisch worden gepersisteerd naar de relationele database. Als ontwikkelaar hoef je je dus niet bezig te houden met XML-mapping files zoals hibernate.cfg.xml of iets dergelijks. GORM heeft zelf converters om een Java-type te mappen op het corresponderende database-type en GORM verzorgt zelfstandig de foreign key relaties tussen de diverse tabellen.

GORM in een notendop

Domein modelleren

Associaties: 1:1, 1:n en n:m relaties

Basic CRUD functionaliteit (Create, Read, Update en Delete)

Biedt dynamic finders voor simpel en snel zoeken (query’s)

Advanced Hibernate Criteria en Hibernate Query Language (HQL)

Constraints (verplichtingsregels) voor het valideren van input data naar domein model

Auto-timestamping (wanneer wordt domein object gesaved en wanneer gewijzigd)

Customizable ORM mapping voor het mappen naar legacy databases

Versioning van records waarmee optimistic locking wordt geïmplementeerd

Voorbeeld van een domein class:

class Book {

            String title

            int price

            static belongsTo = [author:Author]

}

Het codefragment hierboven is een voorbeeld van een eenvoudige domein class. Door het ‘convention over configuration’ principe maakt Grails van de domein class “Book” de tabel “Book” aan in de database.  In de tabel “Book” worden de items “title” en “price” aangemaakt. Tevens wordt door Grails een “author_id” aangemaakt waarmee de foreign key mapping naar de tabel “Author” wordt gerealiseerd. Daarnaast maakt Grails automatisch een ‘”d” property aan in je domein class die als sleutel dient voor de tabel “Book”.

Verder worden door Grails automatisch handige query’s toegevoegd aan de domein class. Deze query’s worden dynamic finders genoemd. Door middel van deze dynamic finders kan Grails  query’s uitvoeren op de database. Ook kan altijd binnen de domein classes terug worden gegrepen op de Hibernate Query Language.

Hieronder staan enige voorbeelden van dynamic finders.

// creëren van een nieuw Boek

def b = new Book(title:”Grails in Action”, price:34.99)

b.save()

// ophalen van een Book op basis van het id

def b = Book.get(2)

// ophalen van alle Boeken

def books = Book.list()

// wijzigen van een Book

def b = Book.get(2)

b.price = 30.00

b.save()

// verwijderen van een Book

def b = Book.get(2)

b.delete()

// enkele dynamic finder voorbeelden

def b = Book.findByTitle(“Grails in Action”)

b = Book.findByTitleLike(“%Grails%”)

b = Boek.findByTitleLikeAndPriceLessThan(“%Grails%”, 30.00)

Tot zover deel 2 van het artikel over Grails. In deel 3 gaan we verder met  Groovy Server Pages en vertellen we meer over controllers en Dynamic Tag Libraries.