Table of Contents
Chapter 1. Grails in a hurry...
1.1.1. First there was Rails...
1.1.2. Why Grails changed the game
1.1.3. Big idea #1: Convention over Configuration
1.1.4. Big idea #2: agile philosophy
1.1.5. Big idea #3: rock-solid foundations
1.1.6. Big idea #4: scaffolding and templating
1.1.7. Big idea #5: Java integration
1.3. Our sample program: a Web 2.0 QOTD
1.3.1. Writing your first controller
1.4. Creating the domain model
1.6. Improving the architecture
1.6.1. Your first Grails test case
1.6.2. Going Web 2.0: Ajax-ing the view
Chapter 2. The Groovy essentials
2.1.1. Let’s play with Groovy!
Chapter 3. Modeling the domain
3.1. Hubbub: starting our example application
3.2. Your first domain class object
3.2.1. Saving and retrieving users via tests
3.3. Validation: stopping garbage in and out
3.4. Defining the data model—1:1, 1:m, m:n
3.4.1. One-to-one relationships
3.4.2. One-to-many relationships
Chapter 4. Putting the model to work
4.1. Creating instant UIs with scaffolding
4.1.1. Scaffolding Hubbub’s domain classes
4.1.2. Scaffolding and validation
4.1.3. Customizing error messages
4.1.4. Managing relationships via scaffolds
4.1.5. Tweaking scaffold layouts with CSS
4.1.6. What can’t you do with dynamic scaffolds?
4.1.7. Static scaffolding: generating and customizing scaffold code
4.1.8. Customizing scaffolding templates: building your own UI generator
4.2. Groovy querying with dynamic finders and Query by Example
4.2.1. Implementing a basic search form
4.2.2. The many faces of dynamic finders
4.2.3. Tuning dynamic finders with eager and lazy fetching
4.2.4. When dynamic finders don’t deliver
4.2.5. Introducing Query by Example (QBE)
4.2.6. Getting dynamic with list(), listOrderBy(), and countBy()
4.3. More sophisticated query options
4.3.1. With great power: criteria querying
4.3.2. Dynamic queries with criteria
4.3.3. Creating a tag cloud using report-style query projections
Chapter 5. Controlling application flow
5.1.1. Implementing a timeline for Hubbub
5.2. Services: making things robust and maintainable
5.3.1. Binding to an existing object
5.3.2. Whitelist and blacklist bind params
5.6. Intercepting requests with filters
5.7. Creating custom URL mappings
5.7.1. myHubbub: rolling your own permalinks
5.7.2. Optional variables and constraints
5.7.3. Handling response codes
Chapter 6. Developing tasty views, forms, and layouts
6.1. Understanding the core form tags
6.1.1. A handful of essential tags
6.1.2. A pocketful of link tags
6.2. Extending views with your own tags
6.3.2. Standardizing page layouts
6.4.1. Choosing a JavaScript library
Chapter 7. Building reliable applications
7.1. Why should we test software?
Chapter 8. Using plugins: adding Web 2.0 in 60 minutes
8.1. Taking advantage of others’ hard work
8.2.1. Installing the Google Chart plugin
8.2.2. Creating your first chart
8.2.3. What’s the story with dataType?
8.2.4. Bar charts: setting custom colors and gridlines
8.2.5. Line charts: handling multiple datasets and line styles
8.4. Full-text search: rolling your own search
8.4.1. Making objects searchable
8.4.3. Implementing pagination
8.4.4. Customizing what gets indexed
8.5.2. Implementing rich-text editing
Chapter 9. Wizards and workflow with webflows
9.2.1. Flow scope: better than Flash scope, cheaper than session scope
9.4.1. Handling input parameters
Chapter 10. Don’t let strangers in—security
10.2. Protecting against malicious intent
10.2.1. Validate all your inputs
10.2.2. Escape all your outputs
10.3.1. Getting started with Spring Security
10.3.3. Getting hold of the current user
10.4. Further exploration of Spring Security
10.4.1. Adding user registration
11.1. Using a RESTful solution
11.1.1. Your first steps in REST
11.2. Negotiating the representation
11.2.1. REST and the params property
11.4. Operation-oriented remoting
Chapter 12. Understanding messaging and scheduling
12.1. A hitchhiker’s guide to messaging
12.1.1. Learning to think in async: what are good messaging candidates?
12.1.2. Messaging terminology: of producers, consumers, topics, and queues
12.2. Using the Grails JMS plugin
12.2.1. Our killer Hubbub feature: IM integration with Jabber
12.4.1. Dealing with re-entrance and stateful jobs
Chapter 13. Advanced GORM kung fu
13.1.1. Exploring inheritance options
13.1.2. Embedding domain classes
13.1.3. Using maps for quick and dirty (or cheap and cheerful) tables
13.2. Caching kung fu: moving from 2 users to 2^10
13.2.1. Hibernate settings: should you use the second-level cache?
13.2.3. Caching individual domain classes
13.2.4. Enough talk, let’s profile
13.2.5. Improving performance with indexed fields
13.3. Legacy integration kung fu: dealing with multiple data sources
13.4. Dealing with difficult legacy databases
13.4.1. Recycling Hibernate mappings
13.4.2. Using GORM DSL to access existing database table structures
Chapter 14. Spring and transactions
14.2. Using transactions with GORM
14.2.1. Easy transactions with services
Chapter 15. Beyond compile, test, and run
15.1.1. Packaging an application
15.2. Build integration—not for the hobbyist
15.3. Coping with a changing data model
Chapter 16. Plugin development
16.1. Creating your first plugin
16.3.1. Enhancing artifacts with dynamic methods
16.3.2. Dealing with class reloading