• Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
613
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
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