Programming Grails: Best Practices for Experienced Grails Developers

by Nelson Beckwith

Overview

Dig deeper into Grails architecture and discover how this application framework works its magic. Written by a core developer on the Grails team, this practical guide takes you behind the curtain to reveal the inner workings of its 2.0 feature set. You’ll learn best practices for building and deploying Grails applications, including performance, security, scaling, tuning, debugging, and monitoring.

Understand how Grails integrates with Groovy, Spring, Hibernate, and other JVM technologies, and learn how to create and use plugins to augment your application’s functionality. Once you know how Grails adds behavior by convention, you can solve problems more easily and develop applications more intuitively.

• Write simpler, more powerful code with the Groovy language
• Manage persistence in Grails, using Hibernate or a NoSQL datastore
• Learn how Grails uses Spring’s functionality and optional modules
• Discover how Hibernate handles details for storing and retrieving data
• Integrate technologies for messaging, mail, creating web services, and other JEE technologies
• Bypass convention and configure Grails manually
• Learn a general approach to upgrading applications and plugins
• Use Grails to develop and deploy IaaS and PaaS applications

Product Details

ISBN-13:	9781449323936
Publisher:	O'Reilly Media, Incorporated
Publication date:	05/14/2013
Pages:	344
Product dimensions:	7.00(w) x 9.10(h) x 0.90(d)

About the Author

Burt Beckwith has been a software developer for 15 years, most of that as a JVM developer, and for the last four years working with Grails and Groovy. He is a core developer on the Grails team at SpringSource, and has created over 35 Grails plugins. Burt is a frequent speaker at conferences and user groups where he shares his passion for Grails and other Groovy-based technologies, in particular those that are related to persistence, security, and performance. He blogs at http://burtbeckwith.com/blog/.

Table of Contents

Preface;
Who This Book Is For;
Other Resources;
Conventions Used in This Book;
Using Code Examples;
Safari® Books Online;
How to Contact Us;
Acknowledgments;
Chapter 1: Introduction to Groovy;
1.1 Installing Groovy;
1.2 Optional Typing;
1.3 Collections and Maps;
1.4 Properties;
1.5 Closures;
1.6 Groovy’s Contributions in the War Against Verbosity;
1.7 Differences Between Java and Groovy;
1.8 Groovy Strings;
1.9 Static this;
1.10 The Groovy JDK (GDK);
1.11 Metaprogramming and the MOP;
1.12 Adding Methods;
1.13 Operators;
1.14 Overload Your Operators;
1.15 def Considered Harmful;
1.16 Closures Versus Methods;
1.17 TypeChecked, CompileStatic, and invokedynamic;
Chapter 2: Grails Internals;
2.1 Installing Grails;
2.2 The Grails Command Line;
2.3 IDE Support;
2.4 Plugins;
2.5 Conventions;
2.6 More Information;
Chapter 3: Persistence;
3.1 Data Mapping;
3.2 Data Validation;
3.3 Transients;
3.4 Mapping Collections;
3.5 Querying;
3.6 Saving, Updating, and Deleting;
3.7 NoSQL Support;
Chapter 4: Spring;
4.1 Inversion of Control and Dependency Injection;
4.2 Bean Scopes;
4.3 Transactional Services;
4.4 Bean Life Cycles and Interfaces;
4.5 Bean Postprocessors;
4.6 Bean Aliases;
4.7 Internationalization;
4.8 Resources;
4.9 Data Binding and Validation;
4.10 Database Persistence;
4.11 Spring MVC;
4.12 Remoting;
4.13 JMS;
4.14 EJBs;
4.15 JMX;
4.16 Email;
4.17 Cache Abstraction;
Chapter 5: Hibernate;
5.1 Mapping Domain Classes;
5.2 Dialects;
5.3 Hibernate Without GORM;
5.4 The Session;
5.5 Open Session in View;
5.6 Custom User Types;
5.7 Optimistic and Pessimistic Locking;
5.8 Accessing the Session’s Connection;
5.9 schema-export;
5.10 SQL Logging;
5.11 Proxies;
5.12 Caching;
5.13 HQL;
5.14 Collections Performance;
5.15 Session.createFilter();
5.16 Custom Configurations;
5.17 Mapping Views and Subselect Classes;
5.18 get(), load(), and read();
5.19 Performance;
Chapter 6: Integration;
6.1 JMS;
6.2 Mail;
6.3 SOAP Web Services;
6.4 REST;
6.5 JMX;
Chapter 7: Configuration;
7.1 External config Files;
7.2 Splitting resources.groovy;
7.3 Modularizing Within resources.groovy;
7.4 Environment-Specific Spring Beans;
7.5 Options for BuildConfig.groovy;
7.6 Adding Additional Source Folders;
Chapter 8: Plugins;
8.1 Creating a Plugin;
8.2 The Plugin Descriptor;
8.3 Splitting Applications into Plugins;
8.4 Building and Releasing;
8.5 Running the Tests;
8.6 Custom Plugin Repositories;
8.7 Plugin Documentation;
8.8 Custom Artifacts;
8.9 Some Notes on Plugin Development Workflow;
Chapter 9: Security;
9.1 OWASP;
9.2 Security Plugins;
9.3 Other Plugins and Libraries;
9.4 General Best Practices;
Chapter 10: The Cloud;
10.1 Cost Savings;
10.2 What You Give Up;
10.3 Cloud Foundry;
10.4 Heroku;
10.5 Other Providers;
10.6 Other Uses for Cloud Services;
Chapter 11: AOP;
11.1 Grails Filters;
11.2 HTTP Filters;
11.3 Groovy AOP;
11.4 Spring AOP;
Chapter 12: Upgrading Applications and Plugins;
12.1 Why Doesn’t the Upgrade Script Do More?;
12.2 A General Approach to Upgrading;
12.3 A Short History of Grails;
12.4 Notes on Upgrading;
Index;
Colophon;