The Definitive Guide to Grails 2 by Brown, Jeff Scott -- Read -- Imperial Library of Trantor

Index

Cover Title Copyright Dedication Contents at a Glance Contents About the Author About the Technical Reviewer Acknowledgments Chapter 1: The Essence of Grails

Simplicity and Power Grails, the Platform Living in the Java Ecosystem Installing and Configuring Grails Creating Your First Application

Step 1: Creating the Application Step 2: Creating a Controller Step 3: Printing a Message Step 4: Testing the Code Step 5: Running the Tests Step 6: Running the Application

Grails Interactive Mode Summary

Chapter 2: Getting Started with Grails

What Is Scaffolding? Creating a Domain Introducing Dynamic Scaffolding

The Create Operation The Read Operation The Update Operation The Delete Operation

Static Scaffolding

Generating a Controller Generating the Views

Being Environmentally Friendly Configuring Data Sources

The DataSource.groovy File Configuring a MySQL Database Configuring a JNDI Data Source Supported Databases

Deploying the Application

Deployment with run-war Deployment with a WAR file

Summary

Chapter 3: Understanding Domain Classes

Persisting Fields to the Database Validating Domain Classes Using Custom Validators Understanding Transient Properties Customizing Your Database Mapping Building Relationships Extending Classes with Inheritance Embedding Objects Testing Domain Classes Summary

Chapter 4: Understanding Controllers

Defining Controllers

Setting the Default Action Logging Logging Exceptions Accessing Request Attributes Using Controller Scopes Understanding Flash Scope Accessing Request Parameters Request Parameter Type Conversions Rendering Text Redirecting a Request

Creating a Model Rendering a View

Finding the Default View Selecting a Custom View Rendering Templates

Performing Data Binding

Validating Incoming Data The Errors API and Controllers Data Binding to Multiple Domain Objects Data Binding with the bindData Method Data Binding and Associations The Bindable Constraint

Working with Command Objects

Defining Command Objects Using Command Objects

Imposing HTTP Method Restrictions

Implementing an Imperative Solution Taking Advantage of a Declarative Syntax

Controller IO

Handling File Uploads Reading the Request InputStream Writing a Binary Response

Using Simple Interceptors

Before Advice After Advice

Testing Controllers Controllers in Action

Creating the gTunes Home Page Adding the User Domain Class Adding a Login Form Implementing Registration Testing the Registration Code Allowing Users to Log In Testing the Login Process

Summary

Chapter 5: Understanding Views

The Basics

Understanding the Model Page Directives Groovy Scriptlets GSP As GStrings

Built-in Grails Tags

Setting Variables with Tags Logical Tags Iterative Tags Filtering and Iteration

Grails Dynamic Tags

Linking Tags The createLink and resource Tags Creating Forms and Fields Validation and Error Handling Paginating Views Rendering GSP Templates Creating Custom Tags Creating a Tag Library Custom Tag Basics Testing a Custom Tag

Summary

Chapter 6: Mapping URLs

Understanding the Default URL Mapping Including Static Text in a URL Mapping Removing the Controller and Action Names from the URL Embedding Parameters in a Mapping Specifying Additional Parameters Mapping to a View Applying Constraints to URL Mappings

Including Wildcards in a Mapping

Mapping to HTTP Request Methods Mapping HTTP Response Codes Taking Advantage of Reverse URL Mapping Named URL Mappings Defining Multiple URL Mappings Classes Testing URL Mappings Summary

Chapter 7: Internationalization

Localizing Messages

Defining User Messages Retrieving Message Values Using URL Mappings for Internationalization

Using Parameterized Messages

Using java.text.MessageFormat Using the message Tag for Parameterized Messages

Using Parameterized Messages for Validation Using messageSource Summary

Chapter 8: Ajax

Writing Ajax Code Ajax in Action Changing Your Ajax Provider Asynchronous Form Submission Fun with Ajax Remote Linking Adding Effects and Animation Ajax-Enabled Form Fields A Note on Ajax and Performance Summary

Chapter 9: GORM

Persistence Basics

Reading Objects Listing, Sorting, and Counting Saving, Updating, and Deleting

Associations

Relationship Management Methods Transitive Persistence

Querying

Dynamic Finders Criteria Queries Detached Criteria Queries Where Queries Query by Example HQL and SQL Pagination

Configuring GORM

SQL Logging Specifying a Custom Dialect Other Hibernate Properties

The Semantics of GORM

The Hibernate Session Session Management and Flushing Obtaining the Session Automatic Session Flushing

Transactions in GORM Detached Objects

The Persistence Life Cycle Reattaching Detached Objects Merging Changes

Performance Tuning GORM

Eager vs. Lazy Associations Batch Fetching Caching Inheritance Strategies

Locking Strategies Events Auto Time Stamping Summary

Chapter 10: Services

Understanding Service Basics Services and Dependency Injection Services in Action

Defining a Service Configuring Service Bean Properties Caching Service Methods Using a Service

Managing Transactions Scoping Services Testing Services Exposing Services Summary

Chapter 11: Integration and Dependency Management

Grails and Configuration

Configuration Basics Environment-Specific Configuration Configuring Logging Stack Trace Filtering Externalized Configuration

Declaring Dependencies

Inheriting Dependencies Declaring Repositories

Understanding the Grails Build System

Creating Gant Scripts Command-Line Variables Parsing Command-Line Arguments Documenting Your Scripts Reusing More of Grails Bootstrapping Grails from the Command Line Gant in Action

Continuous Integration with Hudson Adding Support to Your Favorite IDE

Using The Groovy/Grails Tool Suite (GGTS) Using Spring Tool Suite (STS) and Eclipse IntelliJ IDEA NetBeans Text Editors

Integration with E-mail Servers Deployment

Deploying with Grails Deploying to a Container Application Versioning and Metadata Customizing the WAR

Summary

Chapter 12: Plug-ins

Plug-in Basics

Plug-in Discovery Supplying Application Artefacts Plug-in Hooks Providing Spring Beans Dynamic Spring Beans Using Conventions Plug-in Events and Application Reloading Modifying the Generated WAR Descriptor Packaging and Distributing a Grails Plug-in Local Plug-in Repositories

Plug-ins in Action

Adding Behavior With Plug-ins

Specifying Plug-in Locations on the File System

Plug-ins for Application Modularity

Using the Resources Plug-in Using the Database Migration Plug-in Summary

Index

← Prev
Back
Next →

← Prev
Back
Next →