Grails Introduction - IJTC 2007

Grails Web app development with pleasure! Guillaume Laforge Vice-President, Technology G2One, Inc. http://www.g2one.com

Goal of This Talk Discovering the Grails web framework

Learn more about Grails, how easily you can use it in your projects, and how to get back the pleasure of web development!

Guillaume Laforge

Groovy Project Manager

JSR-241 Spec Lead

Initiator of the Grails framework

Co-author of Groovy in Action

By Dierk König, et al.

Vice-President Technology

Agenda

What’s Grails?

The Problem with the usual web frameworks

The different layers

Other cool features

The plugin system

Summary

Q&A

What’s Grails?

From 10,000 feet

From 1,000 feet

Near the ground

What’s Grails? (1/3)

From 10,000 feet

Grails is an MVC action-based framework

Principles

CoC : Convention over Configuration

DRY : Don’t Repeat Yourself

The essence of Ruby on Rails, but with the tight integration with the Java ecosystem

Protect your investment!

From 1,000 feet

= + +

Near the ground…

Grails is built on proven & solid OSS bricks

Spring : IoC, DI, Spring MVC, transactions…

Hibernate : ORM, querying mechanism

Groovy : for everything that matters

SiteMesh : page layout and composition

Quartz : for job scheduling

AJAX : integration with different libraries

Jetty & HSQLDB : for fast development cycles

The Grails Stack

Why Groovy?

Java-like syntax

Flat learning curve

The same programming models

Same OO, security, threading models

The same libraries

JDK, and any in-house or OSS JAR

And Groovy has…

Closures, properties, malleable syntax for DSLs

The Problem

What’s the problem with Web frameworks?

Why has it got to be complex?

What are the pain points?

Has it got to be complex?

But it’s slow to start with

Seting up the project takes time

It gets complicated pretty rapidly

Dive into Spring & Hibernate to wire everything together

There are so many layers

DAOs, DTOs, more abstraction layers

Too many configuration files

Often too much XML for everything

Struts / Spring / Hibernate is okay…

The Pain Points

ORM persistence overly hard to master and get right

Numerous layers and configuration files lead to chaos

Ugly JSPs with scriptlets and the complexity of JSP tags

Grails addresses the fundamental flaws in Java web application development today without compromising the platform

The Different Layers

Bottom-up!

Transparent persistence

Controllers and services

Groovy Server Pages, templates & taglibs

Grails’ MVC at a Glance…

Model

GORM: Grails Object Relational Mapping

Controller

Multi-action controller

Also the Service layer & Quartz job scheduling

View

GSP: Groovy Server Pages

Tag libraries

Pain Point #1 – Peristence

ORM is quite hard to master and get right

Many configuration files

ibatis.xml hibernate.cfg.xml persistence.xml ejb-cmp.xml

GORM – Grails Object Relational Mapping

Hibernate under the hood

Domain model is a set of POGOs

Plain Old Groovy Objects

POGOs are transparently mapped!

No hibernate.cfg.xml

But can be overriden if needed

All domain classes get useful instance and static methods for free

Book.count(), Book.list(), Book.get(id)…

book.save(), book.delete(), book.update()…

Example

Grails provides a default ORM mapping strategy for Hibernate

// A Book domain class class Book { String title Date releaseDate static belongsTo = [author: Author] } // A one-to-many class User { String name static hasMany = [bookmarks: Bookmark] } 18 8 Dec 2007 Groovy Recipes 17 2 11 Dec 2006 Groovy in Action 16 author_id release_date title id Dierk König 2 name id

<DEMO/>

Constraints

Constraints are added in domain classes through a static constraint field:

static constraint = { isbn(matches: "[0-9]{9}[0-9X]") }

Many constraints available:

blank, creditcard, email, blank, nullable, matches, range, unique, url…

You can create your own validator

myField(validator: { it % 2 == 0 })

No more DAOs!

Dynamic finder methods

Book. findBy Title ("The Stand") Book.findBy Title Like ("Harry Pot%") Book.findBy ReleaseDate Between (start, end) Book.findBy Title LikeOr ReleaseDate LessThan ( "%Grails%", someDate)

Find by relationship

Book.findAllByAuthor( Author.get(1) )

Affect sorting

Book.findAllByAuthor( me, [sort: ‘title’, order: ‘asc’ ] )

Querying

Query by example

Book.find ( new Book(title: ‘The Shining’) )

HQL queries

Book.find( " from Book b where b.title like ‘Lord of%’ " )

Book.find( " from Book b where b.title like ? ", [ ‘Lord of%’ ] )

Criteria builder

def results = Account.createCriteria() { like ("holderFirstName", "Fred%") and { between ("balance", 500, 1000) eq ("branch", "London") } order ("holderLastName", "desc") }.list()

Pain Point #2 – Services, Nav. & Pres. Logic

Numerous layers

Conf file chaos

web.xml xwork.xml applicationContext.xml sitemesh.xml struts-config.xml validator.xml faces-config.xml tiles.xml

Controllers

class Book Controller {

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

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

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

def edit = {

def book = Book.get( params.id )

if(!book) {

flash.message = "Book ${params.id} not found"

redirect(action:list)

} else return [ book : book ]

}

}

http://localhost:8080/myapp/ book / show

Services & Scheduled Tasks

Services are Groovy classes that should contain your business logic

Automatic injection of services in controllers & services simply by declaring a field:

class BookController { MySuperService mySuperService }

Recuring events (Quartz)

Intervals, or cron definitions

class MyJob { def cronExpression = "0 0 24 * * ?" def execute() { print "Job run!" } }

Pain Point #3 – The View Layer

JSP cluttered with scriptlets

Taglibs are painful

c.tld fmt.tld spring.tld grails.tld struts.tld

The view layer

Spring MVC under the hood

Support for flash scope between requests

GSP : Groovy alternative to JSP

Dynamic taglib development:

 no TLD, no configuration, just conventions

Adaptive AJAX tags

Yahoo, Dojo, Prototype

Customisable layout with SiteMesh

Page fragments through reusable templates

Views under grails-app/views

Groovy Server Pages

<html>

<head>

<meta name="layout" content="main" />

<title>Book List</title>

</head>

<body>

<a href=" ${createLinkTo(dir:'')} ">Home</a>

<g:link action="create"> New Book</g:link>

<g:if test="${flash.message}">

${flash.message}

</g:if>

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

</body>

</html>

Dynamic Tag Libraries

Logical : if, else, elseif

Iterative : while, each, collect, findAll…

Linking : link, createLink, createLinkTo

Ajax : remoteFunction, remoteLink, formRemote, submitToRemote…

Form : form, select, currencySelect, localeSelect, datePicker, checkBox…

Rendering : render*, layout*, paginate…

Validation : eachError, hasError, message

UI : richTextEditor…

Write your Own Taglib

Yet another Grails convention

class My TagLib { def isAdmin = { attrs , body -> def user = attrs['user'] if(user != null && checkUserPrivs(user)) body() } }

Use it in your GSP

<g:isAdmin user="${myUser}"> some restricted content </g:isAdmin>

What else?

Custom URL mapping

Conversation flows

ORM DSL

http://grails.org/GORM+-+ Mapping +DSL

Develop with pleasure with IntelliJ IDEA

http:// grails.org /IDEA+ Integration

Custom URL Mappings (1/2)

Pretty URLs in seconds

Custom DSL for mapping URLs to controllers, actions and views

Supports mapping URLs to actions via HTTP methods for REST

Supports rich constraints mechanism

Custom URL Mappings (2/2)

Pretty URLs in seconds!

class UrlMappings { static mappings = { "/product/ $id "(controller: "product", action: "show") "/$blog/ $year? /$month?/$day?"(controller: "blog", action: "show") { constraints { year(matches: /d{4}/) } } }

Conversations flows (1/2)

Leverages Spring WebFlow

Supports Spring’s scopes

Request

Session

Conversation

Flash

Possibly to specify services’ scope

DSL for constructing flows

Conversations flows (2/2)

Example:

def searchFlow = { displaySearchForm { on("submit").to "executeSearch" } executeSearch { action { [results: searchService. executeSearch(params.q)] } on("success").to "displayResults" on("error").to "displaySearchForm" } displayResults() }

Grails plugin system

Beyond the out-of-the-box experience,

extend Grails with plugins

and write your own!

Plugin Extension Points

Extend Grails beyond what it offers!

What can you do with plugins?

Hook into the build system

Script the Spring application context

Register new dynamic methods

Container configuration (web.xml)

Adding new artefacts types

Auto-reload your artefacts

Plenty of Plugins!

XFire

Expose Grails services as SOAP

Searchable

Integrate Lucene & Compass search

Remoting

Expose Grails services over RMI, Burlap, or REST

Google Web Toolkit

Integrate Grails with GWT for the presentation layer

Acegi / JSecurity

Secure your Grails app

JMS

Expose services as message-driven beans

Sweet spot: Enterprise-readiness

Skills, libraries, app servers…

Protect your Investment

Reuse

Existing Java libraries (JDK, 3rd party, in-house)

Employee skills & knowledge (both prod & soft)

Spring configured beans

Hibernate mappings for legacy schemas (but still benefit from dynamic finders)

EJB3 annotated mapped beans

JSPs, taglibs for the view

Deploy on your pricey Java app-server & database

Grails will fit in your Java EE enterprise architecture!

Let’s Wrap Up

Summary

Resources

Q&A

Summary

Groovy is a powerful dynamic language for the JVM, that provides agile development on the Java platform, without the impedance mismatch of other languages

 Groovy 1.1 out next week

Grails is a fully-featured web application framework based on proven technologies like Spring and Hibernate , which simplifies the development of innovative applications