This year we attended Devoxx 2013 with a total of 9 JDriven colleagues. After more than a week we finally recovered from a vast amount of great sessions, personal encounters and 'some' Belgian beer. Looking back at Devoxx we had a great conference and like to thank the Devoxx team for making this possible. It was also good to notice that the majority of the sessions are related to subjects that drive us at JDriven, during our daily job and while further developing our expertise and craftsmanship, to name a few: Continuous Delivery, AngularJS, RESTful API's, Gradle, Groovy, Grails, Java 8, Java EE.
Archive: November 2013
When we convert data to JSON or XML (or any other format actually) in our Grails application we can register custom marshallers. These marshallers must contain the logic to convert an input object to a given format. For example we could have a book class and we want to convert it to our own JSON format. We have different options in Grails to achieve this, but for now we will create a custom marshaller class
CustomBookMarshaller. This class must implement the
ObjectMarshaller<C> interface. The generic type is the converter the marshaller is for and is in most cases either
grails.converters.JSON. Next we must make sure Grails uses our custom marshaller and we must register it. In the Grails documentation is explained how to do this via
grails-app/conf/Bootstrap.groovy where we invoke for example
JSON.registerMarshaller(new CustomBookMarshaller()). Or via
grails-app/conf/spring/resources.groovy where we must write an extra component with a method annotated
JSON.registerMarshaller(new CustomBookMarshaller()) is invoked.
But there is also another way using
org.codehaus.groovy.grails.web.converters.configuration.ObjectMarshallerRegisterer. This is a Spring bean just for configuring extra marshallers. The bean has a
priority property we can use to define the priority for this marshaller. Grails will use a marshaller with the highest priority if for the same class multiple marshallers are defined. We can assign a marshaller to the
marshaller property. And finally we must set the converter class, for example
grails.converters.JSON with the
We can include the
version property of domain classes in rendered JSON or XML output. By default the
version property is not included in generated XML and JSON. To enable inclusion of the
version property we can set the configuration property
grails.converters.domain.include.version with the value
true. With this property for both XML and JSON the
version property is included in the output. To only enable this for XML we use the property
grails.converters.xml.domain.include.version and for JSON we use the property
The following snippet is from
grails-app/conf/Config.groovy where the properties are defined:
If our Grails application renders XML or JSON output we can set configuration properties to enable pretty printing. This can be useful in for example in the development environment where we enable pretty printing and disable it for other environments. We set the configuration property
grails.converters.default.pretty.print with the value
true to enable pretty printing for both XML and JSON output. If we only want to pretty print XML we use the property
grails.converters.xml.pretty.print and for JSON we use
First we look at the XML and JSON output when we don't enable pretty printing for a simple book resource:
We can group URL mappings defined in
grails-app/conf/UrlMappings.groovy using the
group() method defined for the URL mapping DSL. The first argument is the first part of the URL followed by a closure in which we define mappings like we are used to.
Suppose we have defined the following two mappings in our
UrlMappings.groovy file, both starting with /admin:
Since Grails 2.3 we can use the
url-mappings-report command to get a nice report of the URL mappings we have defined in our application. Also implicit mappings created for example by using the
resources attribute on a mapping definition are shown in the report. This report is very useful to see which URLs are exposed by your application and how they map to controllers.
Suppose we have the following
grails-app/conf/UrlMappings.groovy with a couple of mappings:
In Grails we can convert a request parameter to a type directly. We must then use the
list() methods that are added to the
params object available in our controllers.
Since Grails 2.3 we can also pass a default value, which is used when the request parameter is not set. In the following controller we use the
double() method and define a default value of
But sometimes we do want to output unescaped HTML content in the web browser. For example we generate the value ourselves and we know the value is safe and cannot be misused for XSS attacks. In Grails 2.3 we can use a new
raw() method in our GSPs, tag libraries or controllers. The method will leave the content unchanged and return the unescaped value to be displayed. Alternatively we can use
encodeAsRaw() on the content we want to leave unescaped. Finally the
encodeAs tag accepts
None as values for the attribute
codec and will return the unescaped value.
Since Grails 2.3 it is very easy to define RESTful URL mappings for a controller. We can use the
resource attribute and use a controller name as the value. Grails will then automatically create a couple of URL mappings. Suppose we use the following mapping in
"/api/users"(resources: 'user'), then the following mappings are automatically created:
"/api/users/create"(controller: 'user', action: 'create', method: 'GET') "/api/users/(*)/edit"(controller: 'user', action: 'edit', method: 'GET') "/api/users(.(*))?"(controller: 'user', action: 'save', method: 'POST') "/api/users(.(*))?"(controller: 'user', action: 'index', method: 'GET') "/api/users/(*)(.(*))?"(controller: 'user', action: 'delete', method: 'DELETE') "/api/users/(*)(.(*))?"(controller: 'user', action: 'update', method: 'PUT') "/api/users/(*)(.(*))?"(controller: 'user', action: 'show', method: 'GET')
In a Grails application we can organize our controllers into packages, but if we use the same name for multiple controllers, placed in different packages, then Grails cannot resolve the correct controller name. Grails ignores the package name when finding a controller by name. But with namespace support since Grails 2.3 we can have controllers with the same name, but we can use a namespace property to distinguish between the different controllers.
We can add a new static property to a controller class with the name
namespace. The value of this property defines the namespace. We can then write new URL mappings in the
grails-app/conf/UrlMappings.groovy file and use the namespace value as a mapping attribute.