Getting Groovy With Grails

Rochester JUG: 9-Nov-2010
Bryan Basham – Getting Groovy with Grails Slide 1
© Copyright 2010, Software Alchemy
Getting Groovy with Grails
Bryan Basham
Software Alchemy
basham47@gmail.com
http://www.linkedin.com/in/SoftwareAlchemist
Grails
Architecture
Getting
Groovy w/
Grails
Domain
Modeling
Getting
Started

Grails
Architecture
Domain
Modeling
Getting
Groovy w/
Grails
Install
Grails
Create
App
Create
Entity
GUI Scaffolding
Basic
Domain
Modeling
Getting
Started
Getting Started

Install Grails
● Download Grails at http://www.grails.org/
– I am using version 1.3.4 for this tech talk
● Unpack ZIP file on computer
● Set GRAILS_HOME environment variable
● Add $GRAILS_HOME/bin to PATH

Create a Grails App
● Execute command, eg:
grails create-app MyApp

MyApp Use Cases
List employees
Update employee
Create employee
Retrieve employee
Delete employee
Classic CRUD
Operations

Create a Domain Entity
● Create the Employee domain class, eg:
grails create-domain-class com.example.Employee
package com.example
class Employee {
String firstName
String lastName
Integer age
static constraints = {
}
}
«entity»
Employee
{from com.example}
firstName : String
lastName : String
age : Integer

Create a GUI Controller
● Create the Employee controller class, eg:
grails create-controller com.example.Employee
package com.example
class EmployeeController {
def scaffold = Employee
}
● Grails scaffolding provides all basic CRUD
operations and GUI Views

Default GUI Scaffolding

Default GUI Scaffolding (2)

Default GUI Scaffolding (3)

Behind the Looking Glass
● Create the Employee GUI controller class:
grails generate-controller com.example.Employee
class EmployeeController {
def index = {
redirect(action: "list", params: params)
}
def list = {
params.max = Math.min(params.max ? params.int('max') : 10, 100)
[employeeList: Employee.list(params),
employeeTotal: Employee.count()]
}
def save = {
def employee = new Employee(params)
if (employee.save(flush: true)) {
flash.message = "Employee ${employee.id} created."
redirect(action: "show", id: employee.id)
} else {
render(view: "create", model: [employeeInstance: employee])
}
}

Behind the Looking Glass (2)
● Create the Employee GUI views:
grails generate-views com.example.Employee

● The list.gsp View:
<table>
<tbody>
<g:each in="${employeeList}" status="i" var="employee">
<tr class="${(i % 2) == 0 ? 'odd' : 'even'}">
<td><g:link action="show" id="${employee.id}">
${fieldValue(bean: employee, field: "id")}</g:link>
</td>
<td>${fieldValue(bean: employee, field: "age")}</td>
<td>${fieldValue(bean: employee, field: "firstName")}</td>
<td>${fieldValue(bean: employee, field: "lastName")}</td>
</tr>
</g:each>
</tbody>
</table>

● The create.gsp View:
<g:form action="save" >
<table>
<tbody>
<tr class="prop">
<td valign="top" class="name">
<label for="age"><g:message code="employee.age.label" default="Age"
/></label>
</td>
<td valign="top" class="value ${hasErrors(bean: employeeInstance, field:
'age', 'errors')}">
<g:textField name="age" value="${fieldValue(bean: employeeInstance,
field: 'age')}" />
</td>
</tr>
...
</tbody>
</table>
</g:form>

A Simple Relationship
class Employee {
String firstName
String lastName
Integer age
Department department
}
}
«entity»
Department
{from com.example}
name : String
«entity»
Employee
{from com.example}
firstName : String
lastName : String
age : Integer
department
10..*
class Department {
String name
}
}

Create GUI components
● Create Department GUIs and recreate
Employee GUIs
A drop-down list of
department objects,
but the names are
weird.

Fix Department Display
● Add a simple toString method:
class Department {
String name
String toString() { name }
}
}
The toString method is used to
create a useful display name.
You could also create custom
GSP code for the drop-down list
widget.

Grails
Architecture
Conv/Config
Build
tools
Web techPlugins
Groovy
Getting
Groovy w/
Grails
Domain
Modeling
Install
Grails
Create
App
Create
Entity
GUI Scaffolding
Basic
Domain
Modeling
Getting
Started
Grails Architecture

Grails Technology Stack
The Java Virtual Machine
Groovy
Java Lang / JRE JDK
Grails
JavaEE Spring Hibernate SiteMesh
Plugins...
Your Grails Application

Groovy Quick Look
● Groovy is a scripting langage on top of Java
● Syntax for lists and maps:
– [1, 2, 3]
– [foo:1, bar:2, baz:3]
● Closures:
– [1, 2, 3].collect { it * it } => [1, 4, 9]
● Fancy Strings:
– 'foo' is a Java String
– “foo is ${map.foo}” is a GString

Groovy Quick Look (2)
● Groovy classes are JavaBeans
class Employee {
String name
Integer age
}
● Setter/Getters are auto created unless
specified:
class Employee {
String name
Date dateOfBirth
Integer getAge() { /* calc age from DoB */ }
}

Convention over Configuration
● Configuration is kept to a bare minimum
● Convention abounds:
– Entities
– Controllers and URL patterns
– Services and dependency injection
– Tag libraries
– Scaffolding
– and much more

Logging
● Configure logging in grails-app/conf/
Config.groovy file:
log4j = {
root {
info 'stdout'
additivity = true
}
info 'com.example'
// more configuration snipped
}
● Log objects automatically available:
if (employeeInstance.save(flush: true)) {
log.info "Employee ${employeeInstance.id} created."
redirect(action: "show", id: employeeInstance.id)
}

Data Sources
● Configured in the grails-app/conf/
DataSource.groovy file
● Database driver JAR file configured in the
grails-app/conf/BuildConfig.groovy file
● Must create the database before using, but
schema creation is handled by Grails
– Use create-drop to create the DB on every run
– This option destroys any data stored
– Typically used during rapid prototyping

Example: MySQL
● DataSource.groovy:
environments {
development {
dataSource {
dbCreate = "create-drop" // one of 'create', 'create-
drop','update'
url = "jdbc:mysql://localhost:8889/my-app-db"
driverClassName = "com.mysql.jdbc.Driver"
username = "root"
password = "root"
}
}
● BuildConfig.groovy:
dependencies {
runtime 'mysql:mysql-connector-java:5.1.12'
}

Pre-populate DB
● Pre-populate the database using the grails-
app/conf/BootStrap.groovy file:
import com.example.Department;
class BootStrap {
def init = { servletContext ->
if ( Department.count() == 0 ) {
new Department(name:"Accounting").save()
new Department(name:"Marketing").save()
new Department(name:"Development").save()
new Department(name:"Sales").save()
}
}
def destroy = {
}
}
The count() method is
like the SQL statement:
SELECT count(*)
FROM department
The save() method is
like an SQL INSERT
statement.

Eclipse Integration
● Install the Groovy plugin:
http://dist.springsource.org/release/GRECLIPSE/e3.6/
● Groovy support in Eclipse is spotty but
workable
– Hard to find all necessary libraries
– No obvious access to source or javadocs
– Debugging Grails apps is very difficult
● Maven helps with some of these issues

Maven Integration
● Creating a Grails app with Maven 2:
mvn archetype:generate -DarchetypeGroupId=org.grails
-DarchetypeArtifactId=grails-maven-archetype
-DarchetypeVersion=1.3.4
-DgroupId=com.example -Dversion=0.1 -DartifactId=MyMavenApp
cd MyMavenApp/
mvn initialize
● Supporting Eclipse:
mvn -DdownloadSources=true -DdownloadJavadocs=true
eclipse:eclipse

Ant Integration
● You can use Grails scripts in an Ant script
● You can use Ant tasks in your own Grails
scripts, Example:
ant.property(file:"${basedir}/application.properties")
def appName = "${Ant.project.properties['app.name']}"
def appVersion = "${Ant.project.properties['app.version']}"
def appPath = "${appName}-${appVersion}"
target(main: "Create an archive of the complete project source.") {
ant.zip(destfile: "../${appPath}-dist.zip") {
zipfileset(dir:"${basedir}", prefix:"${appPath}") {
exclude(name:"target/**")
exclude(name:"web-app/WEB-INF/classes/**")
}
}
}
setDefaultTarget(main)

External Deployment
● Build a WAR file using this command:
grails dev war
● Deploy to your JavaEE compilant web
container
– WAR includes all Groovy and Grails JARs
– WAR includes all infrastructure JARs
– WAR includes DB driver JAR
– WAR includes all plugins

Web Technologies
● Controllers
● Views: GSPs
● Tag libraries
● Filters

Controllers
● Controllers are Groovy classes that reside in
the grails-app/controllers source directory
● Method names map to URL patterns, eg:
http://localhost:8080/MyApp/employee/list
– Maps to EmployeeController and list method
● View selection:
– Use render to render a specific View component
– Use redirect to tell the browser to redirect
– Return a model Map to render this method's
View, eg. list action renders list.gsp

Views: GSPs
● Very much like JSPs but uses Groovy as the
scripting language; cavet: don't script!
● Use custom tags for view logic
– Large built-in library
– Easy to create your own
● GSP attributes:
– standard JSP attribute scopes plus flash scope
– named values in the action method's model Map
● Grails uses SiteMesh for layout control

Tag Libraries
● Tag libraries are Groovy classes that reside in
the grails-app/taglib source directory
● Each method provides a custom tag, eg:
class MyTags {
def isAdmin = { attrs, body ->
def user = attrs['user']
if ( user != null && checkUserPrivs(user) ) {
out << body()
}
}
}
● No configuration required
● Automatically available in all GSPs, eg:
<g:isAdmin user=”${theUser}”>ADMIN CONTENT</g:isAdmin>

Request Filters
● Filters are Groovy classes that reside in the
grails-app/conf source directory that end in
Filters
class SecurityFilters {
def filters = {
loginCheck(controller:'*', action:'*') {
before = {
if (params.controller == null) {
redirect(action:'login')
return true
} else if(!session.user && !actionName.equals('login')) {
redirect(action:'login')
return false
}
}
}
}
}

Transactions and Services
● Controller actions can be made transactional
– Use Spring SessionFactory injection
– Or use the withTransaction method
● Service components are a better solution
– All classes that reside in the grails-
app/services source directory
– Use the def transactional = true for Spring
transaction AOP wrapping
– Inject the service into the controller:
def storeService // auto-injects StoreService

Plugins
● Grails is a framework built on plugins
● Default plugins:
– Hibernate: the Grails ORM (aka GORM)
– Tomcat: the Grails default runtime environment
● Hundreds of additional plugins
– Security (40)
– Services (117)
– JavaScript frameworks (74)
– many more...

Spring Security Plugin
● Install the plugin:
grails install-plugin spring-security-core
● Create the User and Role entities:
grails s2-quickstart com.example.security User Role
«javaPackage»
com.example.security
«entity»
Role
authority : String
«entity»
User
username : String
password : String
enabled : boolean role
1
0..*
«entity»
UserRoleuser
1
/+authorities

BootStrap Roles and Users
import com.example.security.*;
class BootStrap {
def springSecurityService
def init = { servletContext ->
// Define user role's
def hrRepRole = Role.findByAuthority('ROLE_HR_REP') ?: new
Role(authority: 'ROLE_HR_REP').save(failOnError: true)
def hrMgrRole = Role.findByAuthority('ROLE_HR_MANAGER') ?: new
Role(authority: 'ROLE_HR_MANAGER').save(failOnError: true)
def adminRole = Role.findByAuthority('ROLE_ADMIN') ?: new
Role(authority: 'ROLE_ADMIN').save(failOnError: true)
// a few users:
def adminUser = User.findByUsername('admin') ?: new User(
username: 'admin',
password: springSecurityService.encodePassword('admin'),
enabled: true).save(failOnError: true)
if (!adminUser.authorities.contains(adminRole)) {
UserRole.create adminUser, adminRole
}
// and so on
}
}

Define Security Constraints
● Use annotations on controller actions, eg:
import grails.plugins.springsecurity.Secured
class DepartmentController {
@Secured(['ROLE_HR_MANAGER', 'ROLE_HR_REP'])
def list = { ... }
@Secured(['ROLE_HR_MANAGER'])
def create = { ... }
@Secured(['ROLE_ADMIN'])
def delete = { ... }
}
● Or static URL rules in the Config.groovy file
● Or store the rules in the database

Grails
Architecture
Conv/Config
Build
tools
Web techPlugins
Groovy
Getting
Groovy w/
Grails
Install
Grails
Create
App
Create
Entity
GUI Scaffolding
Basic
Domain
Modeling
Getting
Started
Domain
Modeling
Relationships
Validation
Enumerated
types
Derived
properties
Embedded
properties
Inheritance
Domain Modeling

HrApp Use Cases
View HR action history
Employee
Manager
HR Rep
HR Mgr
View department staff
Promote employee
Issue pay raise for employee
Confirm employee promotion
Confirm employee pay raise
Issue cost-of-living raise to department
Hire employee
Terminate employee
Confirm employee hire
Confirm employee termination
Confirm department COL raise
Create/update job roles

Domain Model is King!

Property Validations
● Property constraints are defined in the Domain
model, eg:
class Employee {
// skipping property definitions
firstName(nullable:false, blank:false, maxSize:32)
lastName(nullable:false, blank:false, maxSize:64)
dateOfBirth(nullable:true)
homeAddress(nullable:false)
homePhone(nullable:false)
cellPhone(nullable:true)
department(nullable:false)
jobRole(nullable:true)
salary(nullable:true, min:10000)
proposedChange(nullable:true)
// workflow properties
user(nullable:false)
status(nullable:false)
}

Basic Enumerated Types
● Grails supports Java-style enums, eg:
class Employee {
// other properties
Status status
enum Status {
CREATED,
HIRED,
DISCIPLINARY_REVIEW,
TERMINATED;
static def getActiveStatuses = {
return [HIRED, DISCIPLINARY_REVIEW]
}
}
// more code
}
● ...but the enum name is stored in the DB field
which is a bit wasteful, so...
«enumeratedType»
Status
+CREATED
+HIRED
+DISCIPLARY_REVIEW
+TERMINATED
«entity»
Employee
firstName : String
lastName : String
...
status : Status

Enumerated Types with Ids
● You can define an id field in the enum, eg:
class EmployeeAction {
// other properties
enum ActionType {
HIRE('HI'),
RAISE('RA'),
COL_RAISE('CR'),
PROMOTE('PO'),
TERMINATE('TE');
final String id
ActionType(String id) {
this.id = id
}
}
// more code
}
● ...so now the DB field is a two-char value.
«enumeratedType»
Status
+HIRE('HI')
+RAISE('RA')
+COL_RAISE('CR')
+PROMOTE('PO')
+TERMINATE('TE')
id : String
«entity»
EmployeeAction
type : ActionType
employee : Employee
newRole : JobRole
...

Derived Properties
● Also know as transient properties, eg:
class Employee {
// Properties
Date dateOfBirth
// Derived properties
Integer getAge() {
// corner case
if ( dateOfBirth == null ) return null;
// calculate and memoize the employee's age
_age = _age ?: DateUtils.dateDiffYears(new Date(), dateOfBirth)
return _age
}
private Integer _age
// GORM constraints
static transients = [ 'age', ... ]
}
«entity»
Employee
dateOfBirth : Date
/age : Integer
...

Derived Relationships
● You can do the same with computed
relationships, eg:
class Employee {
// Derived properties
List<EmployeeAction> getHistory() {
// calculate and memoize the employee's HR history
_history = _history ?: EmployeeAction.findAllByEmployee( this,
[sort:'proposedDate', order:'asc'] )
return _history
}
private List<EmployeeAction> _history
// GORM constraints
static transients = [ 'age', 'history', ... ]
}
«entity»
EmployeeAction/history
*«entity»
Employee

Embedded Properties
● Grails encourages rich object models even for
non-Entity objects, eg:
class Employee {
// Properties
Address homeAddress
PhoneNumber homePhone
PhoneNumber cellPhone
// GORM constraints
static embedded = [ 'homeAddress', 'homePhone', 'cellPhone' ]
}
class PhoneNumber {
// Properties
String areaCode
String prefix
String number
// GORM constraints...
}
«entity»
Employee
homeAddress : Address
homePhone : PhoneNumber
cellPhone : PhoneNumber
«valueObject»
PhoneNumber
areaCode : String
prefix : String
number : String

Embedded Properties (2)
● GORM creates a DB schema with each field of
the Value Object embedded in the fields of the
Entity.
class Employee {
// Properties
Address homeAddress
PhoneNumber homePhone
PhoneNumber cellPhone
}

Relationships
● Grails supports: one-to-one, one-to-many and
many-to-many
● Grails supports uni- and bi-directional
relationships
● Grails support ownership, with cascading
deletes
● Grails supports unordered sets, sorted sets,
and lists (with ordering index)

One-to-One Relationships
class Employee {
// Properties
JobRole jobRole
User user
// GORM constraints
department(nullable:false)
jobRole(nullable:true)
user(nullable:false)
}
«entity»
JobRolejobRole
0..1
«entity»
User
{from com.example.security}
user1
«entity»
Employee
user : User
jobRole : JobRole
department : Department
«entity»
1

One-to-Many
class HRRepresentative extends Employee {
// Properties
Set<Department> departments
// GORM constraints
static hasMany = [ 'departments' : Department ]
}
«entity»
HRRepresentative
departments : Set<Department>
«entity»
Department departments
*

Inheritance
● Inheritance is supported with little to no
configuration
● By default, the whole hierarchy is stored in one
table
● You can configure Grails to use multiple tables
● ...but be aware of the DB performance impact
of multiple selects and table joins

Inheritance (2)
class Employee { ... }
class HRRepresentative extends Employee { ... }
class Manager extends Employee { ... }
class Engineer extends Employee { ... }
«entity»
Employee
«entity»
HRRepresentative
«entity»
Manager
«entity»
Engineer

Inheritance (3)
● The resulting DB table:

Grails
Architecture
Conv/Config
Build
tools
Web techPlugins
Groovy
Getting
Groovy w/
Grails
Install
Grails
Create
App
Create
Entity
GUI Scaffolding
Basic
Domain
Modeling
Getting
Started
Domain
Modeling
Relationships
Validation
Enumerated
types
Derived
properties
Embedded
properties
Inheritance
Q & A

Ten Great Topics Not Covered
1) Supports unit and integration testing
2) Supports RESTful URL patterns
3) Supports Java and Spring integration
4) Supports multiple environments
5) Integration to legacy DBs using Hibernate mappings
6) Supports turning Service components into Web Services
7) Easy to create your own plugins for cross-team sharing
8) Supports other continuous integration tools: Hudson, Ivy, etc
9) Supports data auditing and time stamping w/ GORM event
model
10) Supports Ajax and Spring Web Flows

Resources
● Groovy (http://groovy.codehaus.org/)
– Reference docs (click here)
– Reference card (click here)
● Grails (http://www.grails.org/)
– Reference docs (click here)
● Eclipse plugin
(http://dist.springsource.org/release/GRECLIPSE/e3.6/)
● The Definitive Guide to Grails (by Rocher and
Brown, Apress)

Getting Groovy With Grails

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a Getting Groovy With Grails

Semelhante a Getting Groovy With Grails (20)

Getting Groovy With Grails