Your SlideShare is downloading. ×
Grails presentations
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Grails presentations

632
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
632
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
23
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Rapid Web Application Development with Grails Graeme Rocher Managing Director Agilize it http://www.agilizeit.com Session ID# BOF-2521
  • 2. Goal of this Talk
      • Learn how to rapidly create web applications using the agile web application framework Grails
    Rapid Web Application Development with Grails
  • 3. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 4. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 5. Groovy & Grails
    • Grails: MVC web framework inspired by:
        • Convention over Configuration
        • Don’t Repeat Yourself (DRY)
        • Ruby on Rails
    • Built on solid foundations:
        • Spring IoC, MVC and WebFlow
        • Hibernate
        • SiteMesh
    • Why Groovy?
        • Meta-Programming
        • Closure Support
        • Syntactically Expressive
        • Java Integration
    Source: Please add the source of your data here
  • 6. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 7. Getting Started
    • Grails available from http://grails.org
    • Stable & Development snapshots available
    • Simple installation:
      • Download & extract zip
      • Set GRAILS_HOME variable
      • Add $GRAILS_HOMEin to PATH variable
    • Run “grails create-app ”
    Source: Please add the source of your data here
  • 8. Project Infrastructure
          • + PROJECT_HOME
          • + grails-app
          • + conf
          • + controllers
          • + domain
          • + i18n
          • + services
          • + taglib
          • + views
          • + lib
          • + spring
          • + hibernate
          • + src
          • + web-app
    Main Grails resources Additional Spring configuration Additional Hibernate mapping Web resources e.g. CSS, JavaScript etc. Java sources Jar archive libraries
  • 9. Command Line Targets
    • Apache Ant bundled with Grails
    • Many useful targets available:
      • create-* (for creating Grails artifacts)
      • generate-controller
      • generate-views
      • run-app
      • test-app
      • run-webtest
    Source: Please add the source of your data here
  • 10. The Data Source // data source located in grails-app/conf Class ApplicationDataSource { @Property pooled = false @Property dbCreate = “ create-drop ” @Property url = “jdbc:hsqldb:mem:testDb” @Property driverClassName = “org.hsqldb.jdbcDriver” @Property username = “sa” @Property password = “sa” } Whether connection Pooling is enabled DB Auto creation with hbm2ddl Remaining connection settings
  • 11. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 12. The Application Domain
    • Domain classes hold state and implement behaviour
    • They are linked together via relationships (e.g. one-to-many)
    • In Java domain classes have traditionally been handled by Object-Relational Mapping (ORM)
    • Grails provides simple ORM built on Hibernate
    Source: Please add the source of your data here
  • 13. Grails ORM (GORM)
    • Extremely simple. No special class to extend or file to configure!
    • class ExpenseReport {
    • @Property Long id
    • @Property Long version
    • @Property relatesToMany = [ items :ExpenseItem]
    • @Property Set items
    • @Property Date submissionDate
    • @Property String employeeName
    • }
    Each domain class has an ‘id’ and ‘version’ Defines one-to-many relationship to ExpenseItem
  • 14. Grails ORM (GORM)
    • We’ve got this far, so lets define the other side!
    • class ExpenseItem {
    • @Property Long id
    • @Property Long version
    • @Property belongsTo = ExpenseReport
    • @Property String type
    • @Property Currency currency
    • @Property Integer amount
    • }
    Defines the owning side of the relationship Each property maps To a column
  • 15. Grails Constraints
    • Validation constraints can be defined using the ‘constraints’ property
          • class ExpenseItem {
          • @Property constraints = { type (inList:[ ' travel ' , ' accomodation ' ])
          • amount (range:1..999)
          • }
          • }
    Each node relates to a property Ensures the ‘type’ property Is one of the values in the list ‘ amount’ must be in a range greater than 0 but less than 1000
  • 16. Dynamic Methods & Properties
    • Grails injects methods and properties into domain classes at runtime:
    • def r = ExpenseReport. findBy EmployeeName ( ' fred ' )
    • def r = ExpenseReport
    • . findBy SubmissionDate GreaterThan (lastMonth)
    • def reports = ExpenseReport. findAll ()
    • assert ! (new ExpenseItem(). validate ())
    • def er = new ExpenseReport(employeeName: ' Edgar ' )
    • . save ()
  • 17. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 18. Controllers
    • Controllers handle requests and prepare responses
    • Response created by either delegating to a view or writing to the response
    • A controller is a class containing closure properties that act on requests
    • The convention used for the name of the controller and the actions within map to URIs.
    Source: Please add the source of your data here
  • 19. The Controller
    • The controller and action name map to the URI: /expenseReport/list
    • class ExpenseReport Controller {
    • @Property list = {
    • [ expenseReports : ExpenseReport.list()]
    • }
    • }
    The name of the class is the first token in the URI Each action is a closure property An optional model is returned as a map
  • 20. Data Binding & Flow Control
    • // save action
    • @Property save = {
    • def e = ExpenseItem.get(params.id)
    • e.properties = params
    • if(e. save ()){ redirect(action:show,id:e.id)
    • } else {
    • render( view: ' create ' ,
    • model:[expenseItem:e] )
    • }
    • }
    Auto-type conversion from request parameters Dynamic get method Auto-type conversion To id type Example flow control via render and redirect methods
  • 21. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages (GSP)
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 22. Groovy Server Pages
    • A view technology very similar to JSP, but with Groovy as the primary language
    • More expressive and concise with support for embedded GStrings & Tags
    • Layout support through integration with SiteMesh
    • Ability to define dynamic tag libraries
    Source: Please add the source of your data here
  • 23. A GSP Example
    • The GSP for the list action is named according to convention: grails-app/views/expenseItem/list.gsp
    • <html>
    • <body>
    • <g:each in= &quot; ${ expenseItems } &quot; >
    • <p> ${it.type} – amount: ${it.amount} </p>
    • </g:each>
    • </body>
    • </html>
    References the model returned by the controller Embedded GString expressions
  • 24. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 25. Dynamic Tag Libraries
    • Easy definition of simple, logical and iterative tags:
    • class Expense TagLib {
    • @Property dateFormat = { attrs,body ->
    • out << new SimpleDateFormat( attrs .format)
    • .format( attrs .date)
    • }
    • }
    The name of the tag The body argument is a closure that can be invoked The attributes are passed as a map
  • 26. Dynamic Tag Libraries
    • Using the tag requires no imports or configuration and can be reloaded at runtime!:
    • <p>Submitted:
    • <g: dateFormat date = &quot; ${report.submissionDate} &quot;
    • format = &quot; DD-MM-YYYY &quot; />
    • </p>
    • <p><input type= &quot; hidden &quot; name= &quot; submissionDate &quot;
    • value= &quot; ${ dateFormat (
    • date :report.submissionDate,
    • format : ' DD-MM-YYYY ' )} &quot; />
    • </p>
    Tag called by name with the “g:” prefix Tag can also be called as a regular method!
  • 27. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages
    • Tag Libraries
    • Ajax Support
    • Scaffolding
    • Java Integration
  • 28. AJAX Support
    • Built in “ adaptive ” tag library for Ajax
    • Supports Prototype, Rico, and Yahoo (Dojo coming soon)
    • Tags for remote linking, asynchronous form submission etc.
    • Dynamic “ render ” method available for rendering XML snippets, or partial templates
    • Save/Reload and dynamic tag libraries make Ajax even easier
  • 29. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages
    • Tag Libraries
    • Scaffolding
    • Ajax Support
    • Java Integration
  • 30. DEMO
    • Scaffolding
  • 31. Agenda
    • Groovy & Grails
    • Getting Started
    • The Application Domain
    • Controllers
    • Groovy Servers Pages
    • Tag Libraries
    • Scaffolding
    • Ajax Support
    • Java Integration
  • 32. Java Integration
    • Now for the important bit, with Groovy and Grails you can:
    • Call any existing Java library seamlessly
    • Deploy as a WAR onto any JEE application server
    • Write your domain model in Java , mapped with Hibernate, and still use dynamic methods!
    • Take advantage of Hibernate’s power by mapping onto legacy systems.
    • Use Spring’s dependency injection to integrate Controllers with existing services
  • 33. DEMO
    • ECLIPSE INTEGRATION
  • 34. Summary
    • With the advent on Web 2.0 agility is key
    • Dynamic frameworks (Grails, Rails, Django etc.) provide this through quick iterative development with a clear productivity gain
    • However, for large scale applications static-typing and IDE support is crucial
    • Grails provides the ability to use a blended approach
    • And most importantly it runs on the JVM !
  • 35. For More Information
      • Groovy website – http://groovy.codehaus.org
      • Grails website – http://grails.org
      • Mailing lists – http:// grails.org/Mailing+lists
      • Graeme’s Blog – http://graemerocher.blogspot.com
      • Upcoming books ‘The Definitive Guide to Grails’ by Apress and ‘Groovy in Action’ by Manning
  • 36. Q&A