1 Introduction

Dynamic frameworks like Rails, Django and TurboGears helped pave the way to a more modern way of thinking about web applications. Grails builds on these concepts and dramatically reduces the complexity of building web applications on the Java platform. What makes it different, however, is that it does so by building on already established Java technologies like Spring and Hibernate.

Grails is a full stack framework and attempts to solve as many pieces of the web development puzzle through the core technology and its associated plugins. Included out the box are things like:

• An easy to use Object Relational Mapping (ORM) layer built on Hibernate
• An expressive view technology called Groovy Server Pages (GSP)
• A controller layer built on Spring MVC
• An interactive command line environment and build system based on Gradle
• An embedded Tomcat container which is configured for on the fly reloading
• Dependency injection with the inbuilt Spring container
• Support for internationalization (i18n) built on Spring's core MessageSource concept
• A transactional service layer built on Spring's transaction abstraction

All of these are made easy to use through the power of the Groovy language and the extensive use of Domain Specific Languages (DSLs)

This documentation will take you through getting started with Grails and building web applications with the Grails framework.

1.1 What's new in Grails 3.2?

• GORM Multi Tenancy Support
• GORM for Neo4j 3.0
• RxGORM REST Client

Grails 3.2 includes the following new features.

1.1.1 RxGORM

Initially the only backing implementation supported is MongoDB, however support for GORM REST client and SQL is planned in the future. Refer to the RxGORM documentation for more information.

1.1.2 AngularJS Scaffolding

The Angular scaffolding plugin adds an ng-generate-all command which will generate the necessary AngularJS 1.x client code to perform CRUD operations in conjunction with a Grails 3 backend.

Not only does this serve as a useful tool to get up and running quickly, but (like previous versions of scaffolding) it is a great way for developers to learn how to integrate AngularJS and Grails 3.

Support for Angular 2 is planned for the future.

1.1.3 JSON Views 1.1

Template Inheritance

It is now possible for a child JSON template to specify a parent template, thus allowing better template composition. For example given the following parent:

// grails-app/views/_parent.gson
model {
    Object object
}
json {
    hal.links(object)
    version "1.0"
}

A child template can be specified as follows:

inherits template:"parent"
model {
    Person person
}
json {
    name person.name
}

Global and Default Templates

Global templates can now be created for any GORM custom types. This allows adding support for external libraries such as JodaTime or custom types provided by datastores such as MongoDB (example GeoJSON).

A global template is simply another JSON template that is named after the class name. See for example the GeoJSON templates.

In addition it is now possible to provide a fallback template named /object/_object.gson that is used if no other template is found.

Better HAL Support

The HAL support has been expanded and now includes greater control over _embedded and _links, for example:

model {
    Book book
}
json {
    hal.links(self: book )
    hal.embedded(authors: book.authors)
    hal.inline(book) {
        pages 300
    }
}

The HAL support has also been improved with support for HAL pagination.

1.1.4 Other Novelties

New default date data binding format

Dates formatted like "1970-01-01T00:00:00.000Z" will now be successfully parsed by default. The format is used by common JavaScript libraries.

1.2 What's new in Grails 3.1?

Spring Boot 1.3 and Spring 4.2

Grails 3.1 has been upgraded to Spring Boot 1.3 and Spring 4.2.

1.2.1 Improvements to Grails 3 Profiles

Profile Publishing and Repositories

The following improvements are available in Grails profiles:

• Profiles are now published as regular JAR files to any Maven compatible repository (Artifactory, Nexus etc.).
• Additional profiles can be created easily with the new create-profile command.
• Profiles can now contribute to the generation of the build
• Profiles can now have one or many features

For more information see the new section on Profiles in the user guide.

1.2.2 REST API and AngularJS Profiles

REST Profile

A new profile is available designed for the creation of pure REST applications without a UI.

To create a REST application use the rest-api profile as an argument to create-app:

$ grails create-app myapp --profile=rest-api

In earlier milestones this profile was named web-api. The profile has been renamed rest-api which more appropriately describes its purpose.

Then start interactive mode to see the available commands for the profile:

$ cd myapp
$ grails

If you hit TAB you will notice code generation commands specific to the profile including:

• create-domain-resource - Creates a domain class annotated with the Resource annotation)
• create-restful-controller - Creates a controller that extends RestfulController.

JSON and Markup Views

The REST profile includes the ability to define JSON and Markup views and the build.gradle features the ability to compile these views for production use.

The REST profile also creates JSON views to render the index action and common commands such as generate-views have been overridden to generate JSON views.

AngularJS Profile

An initial version of the AngularJS profile is now available, making it easier to create and integrate AngularJS with Grails 3 applications.

To create a Grails 3 AngularJS application use the angular profile as an argument to create-app:

$ grails create-app myapp --profile=angular

Then start interactive mode to see the available commands for the profile:

$ cd myapp
$ grails

You will notice new commands such as create-ng-component, create-ng-controller etc. that help you get going creating an AngularJS application.

The build.gradle is also preconfigured with the necessary Gradle plugins to integrate AngularJS with Asset Pipeline. The created Angular application can be found in grails-app/assets/javascripts.

1.2.3 GORM 5 Suite

• Hibernate 3, 4 and 5 - for SQL databases GORM for Hibernate now supports the latest Hibernate 5.x release
• MongoDB 3.x - GORM for MongoDB has been upgraded to the MongoDB 3.x Java driver and supports codec based persistence
• Neo4j 2.3.x - GORM for Neo4j has been significantly improved and support the latest release of Neo4j
• Cassandra - GORM for Cassandra supports the latest 2.0.x drivers

For more information refer to the new GORM 5 website.

1.2.4 Plugin Publishing Plugins

To utilize the plugin apply the org.grails.grails-plugin-publish plugin (after any existing Grails plugins for Gradle):

apply plugin: "org.grails.grails-plugin"
apply plugin: "org.grails.grails-plugin-publish"

For a profile the grails-profile-publish plugin can be used instead:

apply plugin: "org.grails.grails-profile"
apply plugin: "org.grails.grails-profile-publish"

Then configure the plugin. For example:

grailsPublish {
    user = 'user'
    key = 'key'
    githubSlug = 'foo/bar'
    license {
        name = 'Apache-2.0'
    }
    title = "My Plugin Title"
    desc = "My Plugin Description"
    developers = [johndoe:"John Doe"]
}

The user and key are your Bintray credentials. With this done you can continue to use bintrayUpload to publish your plugin. In addition, if you wish to update the Grails plugin portal, you simply need to configure your grails.org credentials:

grailsPublish {
    …
    portalUser = "..."
    portalPassword = "..."
}

Then call notifyPluginPortal to update the Grails.org Plugins website:

gradle notifyPluginPortal