Groovy & Grails

Groovy & Grails
Kabisa Kennis Sessie - March 9, 2010

{ Agile Development } { Ruby on Rails } { Java / J2EE }

Groovy & Grails
Groovy


Groovy & Grails
Introduction to Groovy

Groovy is an agile and dynamic language for the JVM
• With a Meta-Object Protocol
• Compiles down to bytecode
• But also supports static typing


Groovy & Grails

Java on steroids:
• Builds upon the strengths of Java, but...
• With power features borrowed from Smalltalk/Python/Ruby
• Makes modern programming features available to Java
developers with a ﬂat learning curve


Groovy & Grails

Java on steroids:
Seamlessly integrates with all existing Java objects and
libraries


Groovy & Grails

Java on steroids:
Seamlessly integrates with all existing Java objects and
libraries
Feels natural to Java developers


Groovy & Grails
From Java to Groovy

A normal Java program
public class HelloWorld {

private String name;

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public String greet() {
return "Hello " + name;
}

public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
helloWorld.setName("Groovy");
System.out.println(helloWorld.greet());
}
}


Groovy & Grails
From Java to Groovy

A valid Groovy program
public class HelloWorld {

private String name;

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public String greet() {
return "Hello " + name;
}

public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
helloWorld.setName("Groovy");
System.out.println(helloWorld.greet());
}
}


Groovy & Grails
From Java to groovy

But hey?
Where are the steroids?


Groovy & Grails
From Java to Groovy

A Groovier program
class HelloWorld {
def name
def greet() { "Hello ${name}" }
}

helloWorld = new HelloWorld(name: "Groovy")
println helloWorld.greet()

Dynamic types using the def keyword
Everything in Groovy is public unless deﬁned otherwise
Automatic getters and setters
Semicolons at end-of-line are optional
Variable interpolation through GStrings
Return keyword is optional


Groovy & Grails
From Java to Ruby

A Ruby program
class HelloWorld < Struct.new(:name)
def greet
"Hello #{name}"
end
end

hello_world = HelloWorld.new("Ruby")
puts hello_world.greet


Groovy & Grails
JVM Languages


Groovy & Grails
Joint Compilation

Total interoperability

Java Interface Groovy Interface

Groovy Class Java Class

Java Class Groovy Class


Groovy & Grails
Native Syntax Constructs

Lists
• Java: int[] numbers = new int[] { 1, 2, 3 };
• Groovy: numbers = [1, 2, 3]
• Ruby: numbers = [1, 2, 3]


Groovy & Grails
Native Syntax Constructs

Lists
• Java: int[] numbers = new int[] { 1, 2, 3 };
• Groovy: numbers = [1, 2, 3]
• Ruby: numbers = [1, 2, 3]

Maps/Hashes
• Java: Map countries = new HashMap();
countries.put("nl", "Netherlands");
countries.put("be", "Belgium");

• Groovy: countries = [nl: "Netherlands", be: "Belgium"]
• Ruby: countries = {:nl => "Netherlands", :be => "Belgium"}


Groovy & Grails
Iterating

Looping
• Groovy: for (i in list) { println i }
• Ruby: for i in list
puts i
end


Groovy & Grails
Iterating

Looping
• Groovy: for (i in list) { println i }
• Ruby: for i in list
puts i
end

Looping with closures
• Groovy: list.each { println it }
• Ruby: list.each {|i| puts i }


Groovy & Grails
GStrings

GStrings are interpolated strings
• Placeholder variables are replaced
• You can have multiline strings
def person = "Marcel"
def letter = """
${new Date()}
Hello ${person},
You have won 100,000,000GBP in the UK lottery!
"""


Groovy & Grails
Special Operators

Elvis operator
• A shortening of Java's ternary operator
def displayName = user.name ? user.name : "Anonymous"
def displayName = user.name ?: "Anonymous"


Groovy & Grails
Special Operators

Elvis operator
• A shortening of Java's ternary operator
def displayName = user.name ? user.name : "Anonymous"
def displayName = user.name ?: "Anonymous"

Safe Navigation Operator
• Java: String postalCode = null;
if (user != null) {
Address address = user.getAddress();
if (address != null) {
postalCode = address.getPostalCode();
if (postalCode != null) {
postalCode = postalCode.toUpperCase();
}
}
}

• Groovy: def postalCode = user?.address?.postalCode?.toUpperCase()

Groovy & Grails
The Groovy Truth

Booleans
def a = true
def b = false
assert a
assert !b

Collections
def numbers = []
assert !numbers // false, as numbers is an empty collection
numbers = [1, 2, 3]
assert numbers // true, as numbers is not empty

Strings
assert 'This is true'
assert !''

Numbers
assert !0 // yeah, 0s are false, like in Perl
assert 1 // this is also true for all other number types

Objects
assert new Object()


Groovy & Grails
Meta Programming

You can add methods and properties to any Object at
runtime
You can intercept method calls and property access
(similar to AOP)
def s = "Hello Groovy"
println s
println s.toUpperCase() // standard JDK method
String.metaClass {
toMixedCase { delegate.toUpperCase() } // add method
toUpperCase { delegate.toLowerCase() } // override existing method
multiply { i -> delegate * i } // add method with argument
}
println s.toMixedCase()
println s.toUpperCase()
println s.multiply(3)


Groovy & Grails
Builders

Simple mechanism for creating any create any structured
tree of data
• You can use out-of-the-box builders
• You can create your own builders
import groovy.xml.MarkupBuilder

def mkp = new MarkupBuilder()
mkp.html {
head {
title "Kabisa ICT"
}
body {
div(class: "container") {
p "Welcome to Kabisa ICT"
}
}
}

println mkp


Groovy & Grails
Do you want to be Groovy?

?

Groovy & Grails
Grails


Groovy & Grails
Introduction to Grails

Full-stack web application framework inspired by
• Code by Convention
• Don’t Repeat Yourself (DRY)
• Ruby on Rails, Django, TurboGears


Groovy & Grails

Built on the shoulders of Giants
• Java/JEE
• Spring framework
• Hibernate


Groovy & Grails

• Java/JEE
• Hibernate
Reduces complexity


Groovy & Grails

• Java/JEE
• Hibernate
Reduces complexity
Increases productivity


Groovy & Grails

• Java/JEE
• Hibernate
Reduces complexity
Increases productivity
“Java”


Groovy & Grails
Full-stack Web Application Framework

Easy Object Relational Mapping (ORM) based on
Hibernate
View layer with Groovy Server Pages (GSP), dynamic Tag
Libraries and SiteMesh
Controller layer based on Spring MVC / Spring Web Flow
Dependency Injection (DI) using the Spring Container
Transactional service layer based on Spring’s transaction
abstraction
Internationalization (i18n) based on Spring’s
MessageSource concept
Embedded Tomcat servlet container for on the ﬂy
reloading


Groovy & Grails
About SpringSource, G2One and VMware

First version of Spring framework was released in 2003


Groovy & Grails

SpringSource was founded in 2004


Groovy & Grails

G2One (The Groovy Grails Company) was founded in
2007 by the Groovy and Grails project leads


Groovy & Grails

In November 2008 G2One was acquired by SpringSource


Groovy & Grails

In August 2009 SpringSource was acquired by VMware for
$420m


Groovy & Grails

In August 2009 SpringSource was acquired by VMware for
$420m
SpringSource is now a division of VMware


Groovy & Grails
Grails Stack

Grails
Other
JEE Spring Hibernate
Libraries
Groovy

Java Development Kit
Java Language
(JDK)

Java Virtual Machine


Groovy & Grails
Grails Command Line
grails create-app book
grails create-domain-class nl.kabisa.book
grails create-controller nl.kabisa.book
grails generate-all nl.kabisa.book
grails install plugin acegi
grails run-app
grails test-app
grails war
grails console
..
Custom commands (scripts) can be added to project


Groovy & Grails
Grails Project Breakdown
grails-app Top level source folder with Grails artifacts
• conf Conﬁguration sources
• controlllers Controller layer
• domain Model layer
• i18n Internationalized Resource Bundles
• services Service layer
• taglib Dynamic Tag Libraries
• views Groovy Server Pages (GSP)
web-app Stylesheets, Javascript, ...
scripts Custom command-line scripts
src Other project sources
• groovy Other Groovy project sources
• java Other Java project sources
lib 3th Party Libraries
test Unit, Integration and Functional tests


Groovy & Grails
Conﬁguration per environment
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"
}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}


Groovy & Grails
GORM

GORM (Grails Object Relational Mapping)
• Domain Modeling
• Basic CRUD methods
• Dynamic Finders
• Events and Auto Timestamping
• Validations
• Custom ORM mappings with ORM Domain Speciﬁc Language


Groovy & Grails
GORM

• Domain Modeling
• Dynamic Finders
• Validations
NO MIGRATIONS
• LiquiBase Plugin


Groovy & Grails
GORM

• Domain Modeling
• Dynamic Finders
• Validations
NO MIGRATIONS
• LiquiBase Plugin
Domain model is OOP based, not database based (as in
Rails)


Groovy & Grails
Domain Classes

Grails Rails
class Book { class User < ActiveRecord::Base
String title end
String isbn
BigDecimal price
}


Groovy & Grails
Domain Classes

Grails Rails
class Author { class Auhor < ActiveRecord::Base
static hasMany = [books: Book] has_many :books
String name end
}

class Book { class Book < ActiveRecord::Base
static belongsTo = [author: Author] belongs_to :author
String title end
String isbn
BigDecimal price
}


Groovy & Grails
Validations, Events, Auto Timestamping, Mappings
class Book {
static belongsTo = [author: Author]

String title
String isbn
BigDecimal price
Date dateCreated
Date lastUpdated

def beforeInsert() {
dateCreated = new Date()
}

static constraints = {
title(blank: false, maxSize: 100)
isbn(blank: false, matches: "[0-9]13", minSize: 13, maxSize: 13, unique: true)
price(nullable: true, min: 0.0, max: 9999.99, scale: 2)
}

static mapping = {
table "books"
price column: "sales_price"
}
}


Groovy & Grails
Basic CRUD methods

Grails Rails
// create # create
def a = new Author(name: "Rowling") a = Author.new(:name => "Rowling")
a.save() a.save

// read # read
def a = Author.get(1) a = Author.find(1)

// update # update
a.name = "J.K. Rowling" a.name = "J.K. Rowling"
a.save() a.save

// delete # delete
a.delete() a.delete


Groovy & Grails
Querying with GORM
// query all authors
def authors = Author.list()

// pagination
def authors = Author.list(max: 10, offset: 20)

// sorting
def authors = Author.list(order: "name", sort: "desc")

// pagination and sorting
def authors = Author.list(max: 10, offset: 20, order: "name", sort: "desc")


Groovy & Grails
GORM Dynamic Finders

FindBy (ﬁrst result)
FindAllBy (all results)
Comparators
• LessThan, LessThanEquals, GreaterThan, GreaterThanEquals
• Like, Ilike, NotEqual, InList, Between
• IsNotNull, IsNull
def author = Author.findByName("J.K. Rowling")

def books = Book.findAllByTileIlike("harry p%")

def books = Book.findAllByPriceLessThan(10.0)

def books = Book.findAllByTitleLikeAndPriceBetween("Harry P%", 10.0, 20.0)


Groovy & Grails
Criteria and HQL
// using criteria builder
def c = Book.createCriteria()
def books = c {
like("title", "Harry P%")
and {
between("price", 10.0, 20.0)
}
order("title", "asc")
}

// using HQL (Hibernate Query Language)
def books = Book.findAll("from Book as b where b.title like ?", ["Harry P%"])


Groovy & Grails
Controllers

Responsible for handling requests
Render or prepare responses
Bind request data to the model (including type conversions)
Support interceptors
Support content negotiation
class SomeController {
def action = {
// do controller logic
// create model
return model
}
}


Groovy & Grails
Controllers

Grails
class BookController {
def list = {
[bookList: Book.list()]
}
}

<ul>
<g:each in="${bookList}">
<li>${it.title}</li>
</g:each>
</ul>


Groovy & Grails
Controllers

Grails
def list = {
[bookList: Book.list()]
}
}

<ul>
<g:each in="${bookList}">
<li>${it.title}</li>
</g:each>
</ul>

Rails
class BooksController < ApplicationController
def list
@books = Book.all
end
end


Groovy & Grails
Example Controller

static allowedMethods = [save: "POST", update: "POST", delete: "POST"]

def index = { redirect(action: "list", params: params) }

def list = {
[bookInstanceList: Book.list(params), bookInstanceTotal: Book.count()]
}

def create = {
def bookInstance = new Book()
bookInstance.properties = params
return [bookInstance: bookInstance]
}

def save = {
def bookInstance = new Book(params)
if (bookInstance.save()) {
redirect(action: "show", id: bookInstance.id)
}
else {
render(view: "create", model: [bookInstance: bookInstance])
}
}


Groovy & Grails
Example Controller
def edit = {
def bookInstance = Book.get(params.id)
if (!bookInstance) {
redirect(action: "list")
}
else {
return [bookInstance: bookInstance]
}
}

def update = {
if (bookInstance) {
bookInstance.properties = params
if (!bookInstance.hasErrors() && bookInstance.save()) {
redirect(action: "show", id: bookInstance.id)
}
else {
render(view: "edit", model: [bookInstance: bookInstance])
}
}
else {
}
}


Groovy & Grails
Example Controller
def delete = {
if (bookInstance) {
bookInstance.delete(flush: true)
}
else {
}
}

def show = {
if (!bookInstance) {
}
else {
[bookInstance: bookInstance]
}
}

def beforeInterceptor = { // do something }

def afterInterceptor = { // do something }
}


Groovy & Grails
XML Responses
def list = {
def bookList = Book.list()
render(contentType: "text/xml") {
books {
for (b in bookList) {
book(title: b.title)
}
}
}
}

// automatic xml marshalling
def list = {
render Book.list() as XML
}


Groovy & Grails
Content Negotiation

You can use HTTP Accept Header
You can use format request paramter (/book/list?format=xml)
You can use URI extension (/book/list.xml)
Use the withFormat method to deal with different
formats
def list = {
def books = Book.list()
withFormat {
html bookList:books
js { render "alert('hello')" }
xml { render books as XML }
}
}
}


Groovy & Grails
Views

Groovy Server Pages (GSP)
• Similar like technologies like JSP and ASP
• A mix of markup and GSP tags
• Groovy code can be embedded, but is discouraged


Groovy & Grails
Views

NO HAML :-(


Groovy & Grails
Views

NO HAML :-(
def show = {
[book: Book.get(params.id)]
}


Groovy & Grails
Views

NO HAML :-(
def show = {
[book: Book.get(params.id)]
}

<%= book.title %>


Groovy & Grails
Views and Tag Libraries

Embedded Groovy code
<html>
<body>
<% [1, 2, 3, 4].each { num ->
if (num > 2) { %>
<p><%= "Hello ${num}!" %></p>
<% }
} %>
</body>
</html>


Groovy & Grails
Views and Tag Libraries

Embedded Groovy code
<html>
<body>
<% [1, 2, 3, 4].each { num ->
if (num > 2) { %>
<p><%= "Hello ${num}!" %></p>
<% }
} %>
</body>
</html>

Use Tag Libraries instead
<html>
<body>
<g:each in="${[1, 2, 3, 4]}" var="num">
<g:if test="${num > 2}">
<p>Number ${num}</p>
</g:if>
</g:each>
</body>
</html>


Groovy & Grails
Core Tag Libraries

Much more attractive than embedded Groovy code


Groovy & Grails
Core Tag Libraries

Like helpers in Rails


Groovy & Grails
Core Tag Libraries

Logic and Iteration <g:if> <g:else> <g:elsif> <g:each> <g:while>


Groovy & Grails
Core Tag Libraries

Links and Resources
<g:link action="show" id="${currentBook.id}">${currentBook.name}</g:link>
<g:link controller="book" action="list">Book List</g:link>


Groovy & Grails
Core Tag Libraries

Links and Resources

Forms and Fields
<g:textField name="title" value="${bookInstance.title}" />
<g:select name="author.id" from="${Author.list()}" value="${bookInstance.author.id}" />
<g:datePicker name="publishDate" value="${bookInstance.publishDate}" />


Groovy & Grails
Core Tag Libraries

Links and Resources

Forms and Fields

Formatting


Groovy & Grails
Core Tag Libraries

Links and Resources

Forms and Fields

Formatting
Ajax


Groovy & Grails
Core Tag Libraries

Links and Resources

Forms and Fields

Formatting
Ajax
and more...


Groovy & Grails
Custom Tag Libraries

Very complex and painful in standard Java
• Complex interfaces to implement
• Additional Tag Library Descriptors (XML) must be written
• And need to be conﬁgured in web.xml


Groovy & Grails
Custom Tag Libraries

Very complex and painful in standard Java
• Complex interfaces to implement
• Additional Tag Library Descriptors (XML) must be written
• And need to be conﬁgured in web.xml
But so easy in Grails
class SimpleTagLib {
static namespace = "auth"
def isAdmin = { attrs, body ->
if (attrs.user.admin)
out << body()
}
}

<auth:isAdmin user="${session.user}">
// some restricted content
</auth:isAdmin>


Groovy & Grails
Views and Layouts
<html>
<head>
<meta name="layout" content="main" />
<title>Book List</title>
</head>
<body>
<div class="nav">
<span><a class="home" href="${createLink(uri: '/')}">Home</a></span>
<span><g:link class="create" action="create">New Book</g:link></span>
</div>
<div class="body">
<div class="list">
<table>
<g:each in="${bookInstanceList}" status="i" var="bookInstance">
<tr class="${(i % 2) == 0 ? 'odd' : 'even'}">
<td><g:link action="show" id="${bookInstance.id}">${bookInstance.id}</
g:link></td>
<td>${bookInstance.title}</td>
</tr>
</g:each>
</table>
</div>
</div>
</body>
</html>


Groovy & Grails
URL Mappings

Used for mapping URL’s to controllers
• Similar like routes in Rails
• Default convention is /controller/action/id


Groovy & Grails
URL Mappings

Used for mapping URL’s to controllers
• Similar like routes in Rails
• Default convention is /controller/action/id
class UrlMappings {
static mappings = {
"/product" (controller: "product", action: "list")
"/product/$id" (controller: "product")
"/$blog/$year/$month/$day/$id" (controller: "blog", action: "show")
}
}


Groovy & Grails
Filters

Controllers already support ﬁne grained interceptors but
these are difﬁcult to manage in larger applications


Groovy & Grails
Filters

Use filters instead
• A Domain Specific Language is available for defining filters
• You can define scopes (all controllers, a specific controller/action, URI pattern)
• You can define interceptor types (before, after, afterView)
• You can use variables (params, request, response, session, grailsApplication)


Groovy & Grails
Filters

Use filters instead
• A Domain Specific Language is available for defining filters
• You can define scopes (all controllers, a specific controller/action, URI pattern)
• You can define interceptor types (before, after, afterView)
• You can use variables (params, request, response, session, grailsApplication)
class SecurityFilters {
def filters = {
loginCheck(controller: '*', action: '*') {
before = {
if(!session.user && !actionName.equals('login')) {
redirect(action: 'login')
return false
}
}
}
}
}

Groovy & Grails
Services

Don’t put core/reusable logic in controllers, but instead
use the service layer
Services are by default transactional
Services can be scoped
class BookService {

static scope = "singleton" // other options include prototype, request, session
static transactional = true

def doSomething() {
// TODO: implement
}
}


Groovy & Grails
Plugins

Grails is designed with a plugin architecture in mind
Grails core features are built on plugins
Plugins can provide basic artifacts
• Domain Classes, Tag Libraries, Services, ...
Plugins can provide new artifact types
Plugins can hook into build events
Plugins can hook into runtime conﬁguration
Plugins can add dynamic methods at runtime


Groovy & Grails
Plugins

Spring Security LDAP
Quartz Commentable
Searchable Selenium RC
Mail Fixtures
Canoo Webtest ReCaptcha
GWT LiquiBase
Feeds GORM-JPA
Taggable iWebKit
Rateable Webdriver
XFire Axis2
Spring WS Wicket


Groovy & Grails
Tooling

Integrated Development Environments
• SpringSource Tool Suite (STS)
• NetBeans
• IDEA IntelliJ
TextMate


Groovy & Grails
Discussion & Demo

!?

Groovy & Grails

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Groovy & Grails

Similar to Groovy & Grails (20)

Recently uploaded

Recently uploaded (20)

Groovy & Grails

Editor's Notes