Quick Overview of Grails

After installing Grails¹, you can create an app by running the following on the command-line:

1   $ grails create-app

Then, you can run commands like create-domain-class and generate-all to create your application as you go. Run grails help to see the full list of commands available.

Grails applications have a very specific project structure. The following is a simple breakdown of most of that structure:

• grails-app—The Grails-specific folder.

  • conf—Configuration, such as the DataSource script and Bootstrap class.

  • controllers—Controllers with methods for index/create/edit/delete or anything else.

  • domain—Domain model; classes representing your persistent data.

  • i18n—Message bundles.

  • jobs—Any scheduled jobs you might have go here.

  • services—Backend services where your backend or "business" logic goes.

  • taglib—You can very easily define your own tags for use in your GSP files.

  • views—Views of MVC; typically these are GSP files (HTML based).

• src—Any utilities or common code that don’t fit anywhere else.

  • java—Java code

  • groovy—Groovy code

• web-app

  • css—CSS stylesheets

  • images—Images used by your web-application

  • js—Your JavaScript files

  • WEB-INF—Spring’s applicationContext.xml goes here

To create a new domain (model) class, run the following:

1   $ grails create-domain-                    class                                                                    

It’s a good idea to include a package for your domain classes (like example.Post).

A domain class in Grails also defines its mapping to the database. For example, here’s a domain class representing a blog post (assuming User and Comment were already created):

 1   class  Post  {
 2       String text
 3       int rating
 4       Date created = new  Date()
 5       User createdBy
 6   
 7       static hasMany = [comments: Comment]
 8   
 9       static constraints = {
10           text(size:10..5000)
11       }
12   }

The static hasMany field is a map that represents one-to-many relationships in your database. Grails uses Hibernate in the background to create tables for all of your domain classes and relationships. Every table gets an id field for the primary key by default.

To have Grails automatically create your controller and views, run the following:

1   $ grails generate-all

When you want to test your app, you simply run the following:

1   $ grails run-app

When you’re ready to deploy to an application container (e.g., Tomcat), you can create a war file by typing this:

1   $ grails war

Plugins

The Grails ecosystem now includes over 1,000 plugins . To list all of the plugins, simply execute this command:

1   $ grails list-plugins

When you’ve picked out a plugin you want to use, execute the following (with the plugin name and version):

1   $ grails install-plugin [NAME] [VERSION]

This will add the plugin to your project. If you decide to uninstall it, simply use the uninstall- plugin command.

REST in Grails

Groovy includes some built-in support for XML, such as the XMLSlurper. Grails also includes converters for converting objects to XML or JSON or vice versa.

 1   import grails.converters.JSON          
 2   import grails.converters.XML          
 3   
 4   class  PostController  {
 5               def getPosts = {
 6                       render Post.list() as  JSON
 7               }
 8               def     getPostsXML = {
 9                       render Post.list() as  XML
10               }
11   }

For REST services that service multiple formats, you can use the built-in withFormat in Grails. So the above code would become the following:

1   def getPosts = {
2           withFormat {
3                   json { render list as  JSON }
4                   xml { render list as  XML }
5           }
6   }

Then Grails would decide which format to use based on numerous inputs, the simplest being the extension of the URL such as .json or the request’s Accept header.

For using web services in Grails, there’s a REST plugin².

Short History of Grails

What follows is a brief history of the features added to Grails starting with version 2.0.

1   grails create-interceptor MyInterceptor

1   boolean before() { true }
2   boolean after() { true }
3   void afterView() {}

Testing

Grails supports unit testing with a mixin approach. Annotations:

• @TestFor(X): Specifies the class under test.

• @Mock(Y): Creates a mock for the given class.

For tests, GORM provides an in-memory mock database that uses a ConcurrentHashMap. You can create tests for tag libraries, command objects, URL-Mappings, XML and JSON, and so on.

Cache Plugin

The Cache plugin can be used to cache content for highly performant web applications.

• You can add the @Cacheable annotation on Service or Controller methods.

• cache tags include cache:block, cache:render

• Includes cache-ehcache, -redis, and –gemfire.

• Cache configuration DSL.

Grails Wrapper

The Grails wrapper was added in Grails 2.0. You can create the wrapper using the following command:

1   $ grails wrapper

This produces grailsw and grailsw.bat (for *nix and Windows, respectively).

The Grails wrapper is helpful when multiple people are working on a project. The wrapper scripts will actually download and install Grails when run. Then you can send these scripts to anyone or keep them in your repository.

Cloud

Grails is supported by the following cloud providers:

• CloudFoundry⁸

• Amazon⁹

• Heroku¹⁰