Grails – The Search is over (deel 3)

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, in deel 2 zijn we verder ingegaan op de Grails omgeving. In dit 3e deel gaan we verder met  Groovy Server Pages en vertellen we meer over controllers en Dynamic Tag Libraries.

Groovy Server Pages – JSP on steroids

Binnen Grails worden Groovy Server Pages (GSP) gebruikt om de views te ontwikkelen. Groovy Server Pages zijn eigenlijk JSP’s on steroids. Een GSP is veel flexibeler en intuïtiever dan een JSP. De taglib binnen GSP is groter maar daarnaast ook makkelijker bruikbaar dan de JSP-tag library. Verder zijn binnen GSP standaard voorzieningen getroffen voor het melden van fouten die tijdens validatie in de controller zijn opgetreden. Ook zijn de GSP-tag libraries voorzien van meer tags om om te gaan met Collections binnen de GSP.

Hieronder een GSP waarmee je de details van een boek op het scherm zou kunnen tonen. Deze source code wordt daadwerkelijk door Grails voor je aangemaakt!

<html>

<body>

<table>

<tr>

<td>Title:</td> <%– JSP-style output –%>

<td><%=book.title%></td>

</tr>

<tr>

<td>Auteur:</td> <%– GSP Expression output –%>

<td>${book.author.name}</td>

</tr>

<tr>

<td>Price:</td> <%– using formatter to format output –%>

<td><g:formatNumber number=”${book.price}” format=”#0.00” />

</td>

</tr>

</table>

<g:form>

<input type=”hidden” name=”id” value=”${book?.id}” />

<g:actionSubmit value=”Edit” />

<g:actionSubmit value=”Delete” />

</g:form>

</body>

</html>

Controllers

De controllers binnen je Grails applicatie zijn verantwoordelijk voor het verwerken van de binnenkomende requests. Je zou de controllers als de obers binnen een restaurant kunnen beschouwen.

Grails gebruikt voor de controllers het bewezen Spring MVC framework.

Grails controllers bieden de volgende functionaliteit:

  • Eenvoudig toegang tot servlet context, session, request, response objecten en de flash variabelen
  • Koppelen tussen Request en View
  • Interceptors (binnen Java EE servlet filters genoemd)
  • Data Binding: de controller koppelt de request parameters aan het domein-object
  • XML en JSON response. Naast HTML kan Grails out-of-the box XML en JSON renderen
  • De nieuwe flash scope – hierin worden meldingen van de controller geplaatst om daarna in de view getoond te worden

Standaard wordt de controller door Grails voorzien van de volgende 7 methodes:

  1. List
  2. Edit
  3. Show
  4. Delete
  5. Update
  6. Save
  7. Create

Deze 7 methodes worden (standaard) door Grails volledig voor je uitgeschreven.

 

class BookController {

def show = {

def book = Book.get(params.id)

return [book:book]

}

def save = {

def book = new Book(params)

book.save()

flash.message = “Boek ${book.id} ingevoerd”

redirect(action:show, id:book.id)

}

}

 

Het bovenstaande codevoorbeeld is een voorbeeld van een controller met twee simpele methodes.

De methodes binnen een controller worden “Actions” genoemd. Actions kunnen data doorgeven aan de views. Dit geschiedt door middel van een Map.

De map bevat een String als key en de data – meestal een domeinobject – als value.

Vanwege het gebruik van Convention over Configuration wordt vanzelf vanuit de show action de show view (show.gsp) vanuit de controller gerendeerd. Indien dit niet wenselijk is kan in de controller gespecificeerd worden welke view gerendeerd moet worden.

 

Dynamic Tag Libraries

Iedere zichzelf respecterende ontwikkelaar weet dat het niet netjes is om Java code (z.g. scriptlets) in een JSP te plaatsen. De Java EE Servlet specificatie heeft hiervoor de custom tag libraries ontwikkeld.

Helaas moeten custom tag libraries eerst in een TLD-bestand worden gedefinieerd. Daarnaast dient er ook onderhoud op deze custom tag libraries te worden uitgevoerd. Gelukkig is het schrijven van een custom tag library in Grails een stuk eenvoudiger – en daardoor productiever en ook leuker – geworden. Om een Grails tag library te ontwikkelen maak je een standaard Groovy class en door conventie kunnen deze vervolgens in je views gebruikt worden zonder dat er een TLD geschreven moet worden. De code hieronder toont een voorbeeld van een Grails Dynamic tag library. Tevens wordt aangegeven hoe die in een view gebruikt kan worden:

 

class BookTagLib {

 

static namespace = “book”

def image = { attrs, body ->

def baseUrl = “pad naar je server” // In ontwikkelomgeving meestal http://localhost:8080”

def title = attrs.book.title

def imageSrc = “${baseUrl}/${title}.gif”

out << ‘<img src=”${imageSrc}” />’

}

}

 

// view code

<html>

<body>

 

<!– deze tag toont een plaatje van het boek –>

<book:image book=”${book}” />

 

.. overige code show.gsp ..

</body>

</html>

In het 4e, en laatste deel van dit artikel gaan we verder in op services, AJAX, testen en plugins. Daarnaast behandelen we IDE’s en de tool Maven. We sluiten vervolgens af met een conclusie en een begrippenlijst.

Meer weten over Grails?

Volg dan onze Grails Programming Training.
Neem voor meer informatie contact met ons op, wij helpen u graag verder!
Vijfhart IT-Opleidingen
088- 542 78 48
info@vijfhart.nl

Tags:
agileApplicatieGrailsGroovyJavaJava EEopen sourceprogrammerenruby on rails
Onderwerpen
Actieve filters: Wis alle filters
Pageloader
PRIVACY VOORWAARDEN

Jouw persoonsgegevens worden opgenomen in onze beschermde database en worden niet aan derden verstrekt. Je stemt hiermee in dat wij jou van onze aanbiedingen op de hoogte houden. In al onze correspondentie zit een afmeldmogelijkheid