Grails 0.3-SNAPSHOT Presentation WJAX 2006

GRAILS
RAPID WEB APPLICATION DEVELOPMENT MADE EASY

about: Sven Haiges
Actionality Deutschland GmbH
Java EE / ME Entwickler
Diplom-Informatiker (FH), MBA
Meine „Framework-Evolution“: Struts, JSF, Spring MVC, GRAILS
Seit August 2006: Grails Podcast, Grails Screencasts

Ziele
Was steckt hinter Grails, wie erzeuge ich meine erste App?
Welche Technologien verbergen sich hinter Grails?
Welche Features sind in Grails enthalten?
Infos zu weiteren Ressourcen

Agenda Basics Grails Foundations MVC Features Roadmap Weitere Infos, Tipps

Grails Basics

Grails MVC
Grails ist ein MVC Web Framework
Inspiriert von Ruby on Rails
Benutzt die mächtige Groovy Scriptsprache
„ Convention Over Configuration”
„ Don't Repeat Yourself“ (DRY)

Grails History & Team
Entstand aus E-Mail Diskussion: Guillaume LaForge, Steven Devijver and Graeme Rocher (aktueller Project Lead)
0.1 am 29. März, 2006
Aktuelles Team: Graeme Rocher, Marc Palmer, Dierk Koenig, Steven Devijer, Jason Rudolph, Sven Haiges... SIE!

Grails im Einsatz...
Standalone
Kein XML, keine aufwändige Konfiguration
0..100 in no time!
Integration mit bestehenden Applikationen
Die Flexibilität von Grails bleibt weitestgehend erhalten, dennoch kann man z.B. das OR-Mapping beliebig konfigurieren
Etwas Integration zu Beginn

Die Basis von Grails
Java EE
Groovy: perfekte Integration mit der Java Plattform, Groovy kompiliert zu bytecode :-)
Spring: IoC, Spring MVC, WebFlow, ...
Hibernate: DER Persistence Layer schlechthin
SiteMesh: flexibles Layout-Framework
Quartz: Job Scheduling
...

Installation
Keine separate Groovy-Installation benötigt, Groovy ist im Download enthalten
grails.org/Installation
Herunterladen, extrahieren, GRAILS_HOME setzen,Grails command line tool zum Path hinzufügen... fertig.
„ grails“ zum Test aufrufen

Ihre erste Grails-Applikation
„ grails create-app“
„ cd appName”
„ grails run-app“
„ grails create-domain-class“, edit class
„ grails generate-all“
„ grails run-app“

Grails Foundations

Spring
Eine Grails Web Application wird durch Spring “zusammengehalten”, im Normalfall ist keine Anpassung dieser Konfiguration notwendig
Eigene Spring Beans können dennoch einfach deklariert werden. Eigene Beans können sehr einfach in Grails Artefakte wie Controller, Services oder Jobs “injected” werden
Eine Grails App ist eine „normale“ Spring MVC-Applikation. Spring Webflow kommt...

Hibernate
Hibernate ist der de facto Standard für O/R Mapping
Grails erzeugt das DB-Schema basierend auf den Domain-Klassen automatisch und legt das Schema in der DB-An / führt Update aus
1:n & m:n seit Grails 0.3
Oftmals ist das DB-Schema bereits vorhanden: Grails erlaubt eigene Hibernate Mappings

SiteMesh
SiteMesh ist ein mächtiges Layout Framework und ist in Grails integriert
grails-app/views/layout/main.gsp definiert das Standard-Layout
Dieses Meta-Element im HTML Header verknüpft eine GSP-Seite mit dem “main” Layout: < meta name = "layout" content = "main" />

Grails Philosophie
Wiederverwendung bestehender Lösungen
Kein “Reinventing the Wheel”
“Coding by Convention”
Ohne jegliche Flexibilität zu verlieren
Domain-Centric, nicht DB-Centric
DRY

Grails MVC

Model
Oben: eine Domain-Class
.groovy-Dateiim grails-app/domain Verzeichnis
Persistent
id, version, equals, hashCode, toString wird von Grails generiert. Diese Methoden können natürlich bei Bedarf überschrieben werden.
class Book {
String title
}

Model
Normalerweise werden Domain-Classes per Grails command line tool erzeugt
Der Task fragt nach dem Namen der Klasse und erzeugt diese im domain-Verzeichnis
Klasse kann ebenso selbst erstellt werden...
> grails create-domain-class

Model
1:1 mapping mit Author
Der “Eigentümer” für cascading update/save wird so festgelegt:
class Book {
Author author
String title
}
class Book {
def belongsTo = Author
Author author
String title
}

Model
1:n mapping: Author hat viele Books
Property “books” automatisch erzeugt
Ebenso die “addXXX”-Methode
class Author {
def hasMany = [ books : Book ]
String name
}
author.addBook(new Book(title:'Grails'))
author.save()

Model
m:n ebenso...
“belongsTo” definiert Eigentümer
class Book {
def belongsTo = Author
def hasMany = [authors:Author]
}
class Author {
def hasMany = [books:Book]
}

Model
Constraints werden per Closure definiert
Auswirkungen auf die erzeugten Views
class User {
String login
String password
String email
Date age
static constraints = {
login(length:5..15,blank:false,unique:true)
password(length:5..15,blank:false)
email(email:true,blank:false)
age(min:new Date().minus(14),nullable:false)
}
}

Model
Dynamic Finder Methods
def results = Book.findByTitle("The Stand")
results = Book.findByTitleLike("Harry Pot%")
results = Book.findByReleaseDateBetween( firstDate, secondDate )
results = Book.findByReleaseDateGreaterThan( someDate )
Ebenso möglich: Query by Example (QBE) Hibernate Criteria Builder, oder direkte HQL-Abfragen!

Model
Datenbank-Konfiguration im grails-app/conf Verzeichnis
DevelopmentDataSource.groovy
ProductionDataSource.groovy
TestDataSource.groovy
“grails run-app” benutzt standardmäßig die “dev” DataSource

Model
“grails war” erzeugt das Deployment WAR-File mit der production datasource
class DevelopmentDataSource {
boolean pooling = true
// one of 'create', 'create-drop','update'
//String dbCreate = "create-drop"
String url = "jdbc:postgresql://localhost:5432/act_dev"
String driverClassName = "org.postgresql.Driver"
String username = "dev"
String password = "devpw"
def logSql = true //enable logging of SQL generated by Hibernate
}

Model
*BootStrap-Files werden zum Start ausgeführt; idealer Ort für die Erzeugung von Test-Daten
class CompanyBootStrap {
def init = { servletContext ->
//Delete all data in the tables that we work on
Company.executeUpdate( "delete Company" )
//now create the test data
Company c1 = new Company(name: 'bmw' )
c1.addUser( new User(name: 'herbert' , admin: true , ...))
.save()
}
...

View
Groovy Server Pages(GSP) oder JavaServer Pages (JSP)
TagLibs für GSP & JSP, GSP ist groovier...
Alle Views sind im grails-app/views Verzeichnis
Die CRUD-Views können einfach generiert werden: “grails generate-views”

View
Beispiel: GSP, benutzt das “main” Layout
< html >
< head >
< meta name = "layout" content = "main" />
< title > BlogEntry List </ title >
</ head >
< body >
< div class = "nav" >
< span class = "menuButton" > < g:link controller = "authentication" action = "viewControllers" > Home </ g:link ></ span >
< span class = "menuButton" >< g:link action = "create" > New BlogEntry </ g:link ></ span >
</ div >
< div class = "body" >
...
</ div >
...

View
Dynamic Tag Libraries
Tags machen endlich wieder Spaß!
“grails create-taglib” erzeugt ein *TagLib.groovy File in grails-app/taglib
Wie mit GSP/Controller updates: kein Server-Restart!

View
TagLib Beispiel (“simple” tag)
class MyTagLib {
includeJs = { attrs ->
out << "<script src='scripts/ ${attrs['script']} .js' />"
}
}
OutputStream ist automatich über “out” erreichbar
Alle Tag-Attribute in der “attrs”-Map

View
Logische und iterative Tags genauso easy
Tags können sogar als “Methoden” aus GSP-Seiten aufgerufen werden:
<g:hasErrors bean="${book}" field="title">
<span class='label error'>There were errors on the book title</span>
</g:hasErrors>
Oder als Methode:
<span id="title" class="label ${hasErrors(bean:book,field:'title','errors')}">Title</span>

View
Einfaches Erzeugen von Markup aus Tags heraus:
def dialog = { attrs, body ->
mkp {
div('class':'dialog') {
body()
}
}
}
Beispiel: Groovy MarkupBuilder

Controller
Alle Controller werden vom Grails dispatcher servlet gemapped
Neuer Controller per: “grails create-controller”
Oder: Generierung auf Basis einer Bestehenden Domain-Klasse: “grails generate-controller”

Controller
Standard-Mapping (Konvention) http://.../appName/controller/action/id
Best. properties automatisch
flash – Map speichert Nachrichten für nächsten Request
log - eine Log4J Logger-Instanz
params – Map mit allen Parametern
request/response/servletContext etc.

Controller
Generierter Controller:
class AdvertisementController {
def index = { redirect(action:list,params:params) }
def list = {
[ advertisementList: Advertisement.list( params ) ]
}
def show = {
[ advertisement : Advertisement.get( params.id ) ]
}
...

Controller
Es geht auch dynamisch:
class BookController {
def scaffold = Book
}
list/show/edit/delete/create/save/ update “dynamisch” verfügbar
Überschreiben einzelner Actions möglich!
“grails generate-all” erzeugt alle Views Controller-Actions für eine Domain Class

Controller
Grails Services können die Business Logik kapseln
Services können sehr einfach in Controller-Klassen aufgerufen werden
“grails create-service” erzeugt einen neuen Service in grails-app/services

Controller
Beispiel-Service
class CountryService {
def String sayHello(String name) {
return "hello ${name}"
}
}
Aufruf aus einem Controller:
class GreetingController {
CountryService countryService
def helloAction = {
render(countryService.sayHello(params.name))
}
}

Scaffolding...
Benutzen Sie es, um schnell eine voll benutzbare Web-Applikation zu haben und um etwas demonstrieren zu können.
Auf dem Weg zum Endprodukt werden Sie sicherlich zahlreiche Änderungen vornehmen müssen.
Benutzen Sie Scaffolding, um schnell zu Lernen! Passen Sie dann alles gemäß Ihren Anforderungen an.

Grails Features

Auto Reloading
Im Development-Modus, synchronisiert Grails die aktuelle Applikation mit dem (Jetty-)Server
Controller, GSPs, Tag Libraries, Domain-Klassen, Services, etc.
Dadurch möglich: iterative und inkrementelle Entwicklung
“agile”

Spring Integration
Zusätzliche Spring-Konfiguration kann im /spring-Verzeichnis abgelegt werden
Automatische DI ist auch für diese Beans verfügbar
Bestehende (Java-) Funktionalität (per Spring) sehr einfach integrierbar

Hibernate Integration
Eigene Hibernate Mappings (HBM Files) für die Domain-Klassen
Die Arbeit mit “legacy database schemas” wird dadurch sehr einfach und effizient
Trotzdem können Sie dynamische Finder-Methoden (GORM) verwenden!

Eclipse “Integration”
Automatisch wird eine Eclipse Projekt-Datei erzeugt - einfach zu importieren: File > Import > Existing Project
Achtung: bie Snapshots müssen ein paar Pfade/Dateinamen aktualisiert werden...
Installieren Sie auf jeden Fall das Groovy Plugin: groovy.codehaus.org/Eclipse+Plugin

AJAX
Grails unterstützt AJAX mit unterschiedlichen AJAX toolkits, momentan Prototype, Dojo und Yahoo
Spezielle AJAX Tags können für asynchrone Aufrufe und Form-Submissions benutzt werden:
<div id="message"></div>
<g:remoteLink action="delete" id="1" update="message">Delete Book</g:remoteLink>

AJAX
Serverseitig unterstützt Grails AJAX durch die render()-Methode. Hier eine AJAX-Response:
def time = {
render (contentType:'text/xml') {
time(new Date())
}
}
Render() unterstützt MarkupBuilder für XML, HTML, JSON und OpenRico

Job Scheduling
Grails macht die periodische Ausführung von Jobs noch einfacher:
class MyJob {
def cronExpression = "0,15,30,45 * * * * ?" //every 15 seconds
def execute(){
println "Running job!"
}
}

Unit & Functional Testing
Sowohl Unit- als auch Functional-Testing werden unterstützt
Functional Testing: Canoo Webtest
“grails test-app” startet alle Unit-Tests
“grails run-webtest” für alle WebTests
Funktionale Tests werden einfach per scaffolding erzeugt:
“grails generate-webtest”

Grails Roadmap

Die Sandbox
Neue Controllers
Page Flows (WebFlow)
Constraints für DB-Schema-Erzeugung
Laszlo on Grails
Mail / Messaging Integration
Test DataSets
Plugin-System

Roadmap
0.3
Spring 2
Web Services Service Classes
M:N Mapping for GORM
0.4
DWR Support für Service Classes
Pluggable Persistence Layer

Roadmap
0.5
XML-RPC for Service Classes
Generation des Domain Model vom DB Schema
0.6
Scaffolding für User Authentication Code
Grails ist immer noch klein und fein: Sie entscheiden, was wichtig wird: http://jira.codehaus.org/browse/GRAILS

Weitere Infos, Tipps

Weitere Infos...
Herunterladen, Installieren, die erste App erzeugen mit dem QuickStart Guide: http://www.grails.org/Quick+Start
Tutorials lesen: http://www.grails.org/Tutorials

Weitere Infos...
Den User Guide lesen und ausprobieren: http://www.grails.org/User+Guide
Die Grails Mailing List lesen: http://www.grails.org/Mailing+lists
Achtung: Grails ist open source...
Je mehr Sie selbst dazu beitragen, desto schneller lernen Sie Grails kennen

“SEE” the Light
Derzeit gibt es 2 Screencasts über Grails:
Scaffolding
Directory Structure
http://www.grails.org/Grails+Screencasts

Grails Podcast
Grails Podcast
~ wöchentlich
Grails News
Grails Features
Interviews
Agile Development
http://hansamann.podspot.de/rss

Lesestoff
Erscheint in Kürze!
Von Graeme Rocher, Grails Project Lead
ISBN: 1-59059-758-3

Machen Sie mit!
Veröffentlichen Sie z.B. einen Tag! grails.org/Contribute+a+Tag
Bloggen Sie über Grails!
Beantworten Sie Fragen in der Grails User List
und...

Groovy & Grails Shop
Kaufen Sie endlich einen richtigen “GString”!
http://tinyurl.com/y3zmos
Neu!

GRAILS
RAPID WEB APP DEVELOPMENT MADE EASY
Vielen Dank! Fragen?
www.grails.org www.svenhaiges.de
skype: hansamann

http://www.thorsten-kamann.de	12
http://www.flavor.de	6
http://www.slideshare.net	2

Grails 0.3-SNAPSHOT Presentation WJAX 2006

by Sven Haiges

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 20

Statistics

Grails 0.3-SNAPSHOT Presentation WJAX 2006 Presentation Transcript