This document outlines an agenda for a Grails beginners workshop. It includes installing Grails, an introduction to Grails, creating a sample conference application, and exercises. The sample application allows attendees to register for talks and rate them. Domain classes are created for Attendee, Talk, and Rating with relationships. Services are introduced to move logic from controllers. Taglibs, assets, styling with Bootstrap, and layouts are also covered.

1. GRAILS - BEGINNERS WORKSHOP
Jacob Aae Mikkelsen

2. AGENDA
Installing Grails
Grails Intro
Application Scenario
Creating the application
Exercises

3. JACOB AAE MIKKELSEN
Senior Engineer at Lego
Microservice based architechture on JVM
Previously 4 years at Gennemtænkt IT
Consultant on Groovy and Grails
External Associate Professor - University of Southern
Denmark
@JacobAae
Blogs The Grails Diary

4. INSTALLING GRAILS

5. USB WITH MATERIAL
On the USB Sick passed around, the following materials are
available
These slides
Git repository with Grails application
Grails
IntelliJ editor
Bootstrap files

6. MAC & LINUX
Use Gvm tool
curl ­s get.gvmtool.net | bash
Restart terminal
gvm install grails 3.0.1

7. WINDOWS
Option 1: Use GVM Tool in Cygwin
Option 2: Use Posh-GVM in Powershell
( )https://github.com/flofreud/posh-gvm
Option 3 Download Grails, and setup GRAILS_HOME
(
)
http://grails.asia/grails-tutorial-for-beginners-setup-your-
windows-development-environment/

8. GRAILS INTRO
Grails is a full stack framework
-
Embrace the Don’t Repeat Yourself (DRY) principle
-
Encourages proper testing
-
Use the Groovy language and extensive use of Domain
Specific Languages (DSLs)

9. INCLUDED WITH GRAILS
Object Relational Mapping (ORM) layer → Hibernate
Expressive view technology → Groovy Server Pages (GSP)
Controller layer → Spring MVC
Interactive command line env and build system → Gradle
Embedded Tomcat container with on the fly reloading
Dependency injection → Spring container
i18n → Spring’s core MessageSource concept
Transactional service layer → Spring’s transaction
abstraction

10. LATEST VERSION: 3.0.1
Groovy 2.4
Spring 4.1 and Spring Boot 1.2
Gradle Build System
Application Profiles
Redesigned API based on Traits
Filters → Interceptors
Main class → Easy to run from any IDE

11. APPLICATION SCENARIO
Lets make a small conference application that can
keep track at what talks and workshops you have
attended
let attendees rate and supply feedback

12. MODEL
We need 3 domain classes in this small application
Attendee
Talk
Rating

13. ATTENDEE
Name
Email
Which talks attended

14. TALK
Speaker name
Starting time
List of ratings and comments

15. RATING
Attendee who supplied the rating
The talk it rates
The rating (1-5)
Comment

16. FUNCTIONALITY
Attendees must be able to register which talks he
attended
An attendee must be able to rate a talk from 1-5 and
submit a comment too
A list of comments and an average grade must be
available when vieving a talk

17. STEP 1: CREATING THE APPLICATION
To create a new Grails Application, run the grails
create-appcommand in a terminal
grails create­app eu­gr8conf­grailsdemo
Lets go through the tree view of whats generated
You don’t have to do the above step, if you clone this
repo - then it is all done :)

git clone https://github.com/JacobAae/eu­gr8conf­grailsdemo.git

18. WHATS GENERATED (1)
.
├── build.gradle
├── gradle
│ └── wrapper
│ ├── gradle­wrapper.jar
│ └── gradle­wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat

19. WHATS GENERATED (2)
├── grails­app
│ ├── controllers
│ │ └── UrlMappings.groovy
│ ├── domain
│ ├── services
│ ├── taglib
│ ├── utils
│ └── views
│ ├── error.gsp
│ ├── index.gsp
│ ├── layouts
│ │ └── main.gsp
│ └── notFound.gsp

20. WHATS GENERATED (3)
└── grails­app
├── assets
│ ├── images
│ ├── javascripts
│ └── stylesheets
├── conf
│ ├── application.yml
│ ├── logback.groovy
│ └── spring
│ └── resources.groovy
└── i18n

21. WHATS GENERATED (4)
└── grails­app
└── init
├── BootStrap.groovy
└── eu
└── gr8conf
└── grailsdemo
└── Application.groovy

22. WHATS GENERATED (5)
└── src
├── integration­test
│ └── groovy
├── main
│ ├── groovy
│ └── webapp
└── test
└── groovy

23. RUNNING OUR APP
To get to the interactive console:
grails
In interactive mode
run­app

24. RESULT
Go to: http://localhost:8080/

25. STEP 2: FIRST DOMAIN CLASS
Lets create the first domin class with controller and views:
Attendee

26. CREATING THE DOMAIN CLASS
In interactive mode
create­domain­class eu.gr8conf.grailsdemo.Attendee
Resulting in
| Created grails-app/domain/eu/gr8conf/grailsdemo/Attendee.groovy
| Created src/test/groovy/eu/gr8conf/grailsdemo/AttendeeSpec.groovy

27. RUNNING TESTS
In interactive mode
test­app
Which fails since we have not yet implemented any test

28. PROPERTIES AND CONSTRAINTS
Edit the Attendee class to contain
String name
String email
String nationality
Date dateCreated
Date lastUpdated
static constraints = {
name blank: false
email blank: false, unique: true, email: true
nationality nullable: true
}

29. GORM
Adds lots of convenience
validate()
save()
get(id)
delete()
list()
Dynamic finders: Attendee.findByName('Jacob')

30. TESTING
Here is an example of a test for constraints that are violated
@Unroll
void "Test invalid properties for attendee: #comment"() {
when:
Attendee attendee = new Attendee(name: name,
email: email, nationality: nationality)
then:
!attendee.validate()
where:
name | email | nationality | comment
'' | 'jacob@gr8conf.org' | 'Danish' | 'Blank name'
}
INFO: Lets add positive and more negative tests for the
constraints.

31. CONTROLLER AND VIEWS
In interactive mode
generate­all eu.gr8conf.grailsdemo.Attendee
And run the app again - and click the controller

32. EXERCISE
Open AttendeeControllerSpec.groovyand update
it, so the tests passes

33. STEP 3: MORE DOMAIN CLASSES
Lets make the other two domain classes, and see how they
can interact

34. HINTS
create­domain­class eu.gr8conf.grailsdemo.Talk
create­domain­class eu.gr8conf.grailsdemo.Rating
generate­all eu.gr8conf.grailsdemo.Talk
generate­all eu.gr8conf.grailsdemo.Rating

35. RELATIONS
Attendee.groovy
static hasMany = [talks: Talk]
Talk.groovy
static belongsTo = Attendee // Where the addTo method will work from i.e. c
static hasMany = [attendees: Attendee,ratings: Rating]
Rating.groovy
static belongsTo = [talk:Talk]

36. CONTROLLERS
A controller handles requests and creates or prepares the
response
Business logic placed elsewhere (services)
Placed in controller folder and ends in Controller
Methods → actions
Databinding

37. VIEWS AND TEMPLATES
Made with Groovy Server Pages (GSP)
Extensive suite of tags
formatting
looping
input fields

38. CONTROLLERS AND VIEWS
Problem: Lets make a new Display Attendee page, where we
can see talks attended better.
What to do:
Make a displayaction in the AttendeeController
Add a display.gspview
add link to the new display or replace the show action
We could also rewrite the show action :)

39. THE ACTION
def display(Long id) {
Attendee attendee = Attendee.get(id)
respond attendee
}

40. THE VIEW
Copy and paste the show.gspview, and replace
<f:display bean="attendee" />
with

41. THE VIEW (2)
<ol class="property­list attendee">
<li class="fieldcontain">
<span id="name­label" class="property­label">Name</span>
<span class="property­value" aria­labelledby="name­label">
${attendee.name}</span></li>
<!­­ email and nationalityleft out ­­>
<li class="fieldcontain">
<span id="talks­label" class="property­label">Talks</span>
<span class="property­value" aria­labelledby="talks­label">
<ul>
<g:each in="${attendee.talks}" var="talk">
<li>${talk.title}</li>
</g:each>
</ul>
</span>
</li>
</ol>

42. EXERCISES
Make a link for each talk to go to an add rating page
Implement the add rating functionality

43. STEP 4: SERVICES
The default code leaves too much logic in the controller, this
should be in a service, that also should handle transactions
etc.
Lets try to cleanup the attendee controller and place some
of the logic in a service

44. SERVICES
Are transactional by default
Easy to autoinject
Great place for logic and functionality

45. HINTS
create­service eu.gr8conf.grailsdemo.AttendeeService

46. USING SERVICES - AUTOINJECTION
In the AttendeeController, where we will use the service, all
we need to do, is add this line
AttendeeService attendeeService
Then it will be autoinjected because Grails recognices the
name

47. CLEANING UP CONTROLLERS
The default generated controllers does everything
Lets cleanup the save method.

48. HELPER CLASSES
In src/main/groovyyou can place helper classes, or
non-Grails-artefacts
class Result {
def item
Status status
}
enum Status {
OK,
NOT_FOUND,
HAS_ERRORS
}

49. SERVICE METHOD
The service method could look like
Result saveAttendee(Attendee attendee) {
if (attendee == null) {
transactionStatus.setRollbackOnly()
return new Result(status: Status.NOT_FOUND)
}
if (attendee.hasErrors()) {
transactionStatus.setRollbackOnly()
return new Result(status: Status.HAS_ERRORS, item: attendee)
}
attendee.save flush:true
return new Result(status: Status.OK, item: attendee)
}

50. CONTROLLER
def save(Attendee attendee) {
Result result = attendeeService.saveAttendee(attendee)
switch( result.status) {
case Status.NOT_FOUND:
notFound()
break
case Status.HAS_ERRORS:
respond result.item.errors, view:'create'
break
case Status.OK:
request.withFormat {
form multipartForm {
flash.message = message(code: 'default.created.message
println attendee.dump()
redirect attendee
}
'*' { respond attendee, [status: CREATED] }

51. TASK
Clean up the rest of the controller, removig everything that
needs the @Transactional annotation

52. STEP 5: TAGLIBS
Taglibs can help make the views more clean and DRY

53. TAGLIB
Placed in grails-app/taglib
must end with TagLib.groovy
Closure taking parameters attrsand body
create­taglib eu.gr8conf.grailsdemo.RatingTagLib

54. SERVICE TO CALCULATE AVERAGE
RATING
class TalkService {
BigDecimal calculateAverageRating(Talk talk) {
if( !talk || !talk.ratings ) {
return null
}
talk.ratings*.value.sum() / talk.ratings.size()
}
}

55. THE TAGLIB
TalkService talkService
def showRating = { attrs ­>
Talk talk = attrs.talk
BigDecimal avg = talkService.calculateAverageRating(talk)
if( avg ) {
out << """<span class='average­rating'>
${roundAverage(avg)}</span>"""
} else {
out << "N/A"
}
}
private roundAverage(BigDecimal average) {
"${Math.round(1.0 * average * 100) / 100 }"
}

56. TESTING TAGLIBS
void "test output from showRating"() {
when:
String output = tagLib.showRating(talk:
new Talk(ratings: ratings), { a ­> a })
then:
output == expected
where:
ratings | expected
null | 'N/A'
[new Rating(value: 5)] | "<span class='average­rating'>5</span>
}

57. STEP 6: ASSETS, STYLING, PLUGINS
AND LAYOUTS

58. ASSETS
Javascript, images and css files are handled by asset-
pipeline plugins
build.gradle
runtime "org.grails.plugins:asset­pipeline"
Compiles Less
Minifies JS
Combines files

59. BOOTSTRAP
Lets include the (Twitter) Bootstrap project in our
application.

60. BOOTSTRAP
In the grails-app/assetsfolder, place the Bootstrap
files
.
├── fonts
│ ├── glyphicons­halflings­regular.eot
│ ├── ... + rest of fonts files
├── images
│ ├── ...
├── javascripts
│ ├── bootstrap.css.map
│ └── bootstrap.js
└── stylesheets
├── bootstrap.css
├── bootstrap­theme.css
├── combined­bootstrap.css
├── ...

61. ASSET FILE
Lets make a Bootstrap css asset package
combined-bootstrap.css
/*
*= require bootstrap
*= require bootstrap­theme
*= require_self
*/

62. LAYOUTS
In grails-app/views/layoutsLayonts are placed
that can be reused across pages.

63. LAYOUTS
views/layouts/bootstrap.gsp
<!doctype html>
<html lang="en" class="no­js">
<head>
<meta http­equiv="Content­Type" content="text/html; charset=UTF­8
<meta http­equiv="X­UA­Compatible" content="IE=edge">
<title><g:layoutTitle default="Grails"/></title>
<meta name="viewport" content="width=device­width, initial­scale=1
<asset:stylesheet src="combined­bootstrap.css"/>
<asset:javascript src="application.js"/>
<g:layoutHead/>
</head>
<body class="container">
<g:layoutBody/>
<div class="footer" role="contentinfo"></div>
<div id="spinner" class="spinner" style="display:none;"><g:message
</body>
</html>

64. USING LAYOUTS
views/attendee/display.gsp
<head>
<meta name="layout" content="bootstrap">
...
views/attendee/display.gsp
<g:link class="btn btn­primary" action="edit" resource="${attendee}"
<span class="glyphicon glyphicon­edit" aria­hidden="true"></span>
<g:message code="default.button.edit.label" default="Edit" />
</g:link>

65. FIXING ICONS
In bootstrap.css, update the path to Glyphicons font
(line 267++)
views/attendee/display.gsp
@font­face {
font­family: 'Glyphicons Halflings';
src: url('../assets/fonts/glyphicons­halflings­regular.eot');
src: url('../assets/fonts/glyphicons­halflings­regular.eot?#iefix') for
}

66. TASKS
Include Bootstrap
Restyle a page using a bootstrap layout

67. EXERCISES
Show the distribution of grades in the talk page (2*3, 2*4,
4*5)

68. LITERATURE
http://gvmtool.net/
https://github.com/flofreud/posh-gvm
https://grails.org/single-page-documentation.html
http://getbootstrap.com/