Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 92 Next »

Groovy 1.8 release notes

The 1.8 release of Groovy comes with many new features that greatly enhance

  • the dynamic expressiveness of Groovy, specifically for defining DSLs
  • runtime performance
  • concurrent and parallel execution
  • design by contract
  • functional programming style
  • first-class JSON support
  • compile-time meta programming
  • and more helpers and library additions

These features have undergone the Groovy developer process with formal descriptions, discusssion, and voting (GEP - Groovy Enhancement Proposal) for core parts and less formal developer discussions and JIRA voting for additional parts.

Our goal has stayed the same, though: to give the Java developer a tool that makes him more productive, allows him to achieve his goals faster and with a smaller margin of error, and extend the scalability of the Java platform from full-blown enterprise projects to everyday "getting things done" tasks.

Command chains for nicer Domain-Specific Languages

Thanks to its flexible syntax and its compile-time and runtime metaprogramming capabilities, Groovy is well known for its Domain-Specific Language capabilities. However, we felt that we could improve upon the syntax further by removing additional punctuation symbols when users chain method calls. This allows DSL implementors to develop command descriptions that read almost like natural sentences.

Before Groovy 1.8, we could omit parentheses around the arguments of a method call for top-level statements. But we couldn't chain method calls. The new "command chain" feature allows us to chain such parentheses-free method calls, requiring neither parentheses around arguments, nor dots between the chained calls. The general idea is that a call like a b c d will actually be equivalent to a(b).c(d). This also works with multiple arguments, closure arguments, and even named arguments. Furthermore, such command chains can also appear on the right-hand side of assignments. Let's have a look at some examples supported by this new syntax:

It is also possible to use methods in the chain which take no arguments, but in that case, the parentheses are needed:

If your command chain contains an odd number of elements, the chain will be composed of method / arguments, and will finish by a final property access:

This new command chain approach opens up interesting possibilities in terms of the much wider range of DSLs which can now be written in Groovy. This new feature has been developed thanks to the Google Summer of Code program, where our student, Lidia, helped us modify the Groovy Antlr grammar to extend top-level statements to accept that command chain syntax.

The above examples illustrate using a command chain based DSL but not how to create one. You will be able to find some further examples of "command chains" on the Groovy Web Console but to illustrate creating such a DSL, we will show one example - first using maps and Closures:

Or if you prefer Japanese and a metaprogramming style (see here for more details):

Performance improvements

Groovy's flexible metaprogramming model involves numerous decision points when making method calls or accessing properties to determine whether any metaprogamming hooks are being utilized. During complex expression calculations, such decision points involved identical checks being executed numerous times. Recent performance improvements allow some of these checks to be bypassed during an expression calculation once certain initial assumptions have been checked. Basically if certain preconditions hold, some streamlining can take place.

Groovy 1.8.0 contains two main streams of optimization work:

  • There are several optimizations for basic operations on integers like plus, minus, multiply, increment, decrement and comparisons. This version doesn't support the mixed usage of different types. If an expression contains different types, then it falls back to the classical way of performing the operation, i.e. no streamlining occurs.
  • There is also an optimization for direct method calls. Such a method call is done directly if it is done on "this" and if the argument types are a direct match with the parameter types of the method we may call. Since this is an operation that does not behave too well with a method call logic based on runtime types we select only methods where the primitive types match, the parameter types are final or for methods that take no arguments. Currently methods with a variable parameter list are not matched in general, unless a fitting array is used for the method call.

Those two areas of optimization are only the beginning of further similar improvements. Upcoming versions of the Groovy 1.8.x branch will see more optimizations coming. In particular, primitive types other than integers should be expected to be supported shortly.

GPars bundled within the Groovy distribution

The GPars project offers developers new intuitive and safe ways to handle Java or Groovy tasks concurrently, asynchronously, and distributed by utilizing the power of the Java platform and the flexibility of the Groovy language. Groovy 1.8 now bundles GPars 0.11 in the libraries of the Groovy installation, so that you can leverage all the features of the library for
Fork/Join, Map/Filter/Reduce, DataFlow, Actors, Agents, and more with all the Groovy goodness.

To learn more about GPars, head over to the GPars website, read the detailed online user guide, or check out chapter 17 of Groovy in Action, 2nd Edition (MEAP).

Closure enhancements

Closures are a central and essential piece of the Groovy programming language and are used in various ways throughout the Groovy APIs. In Groovy 1.8, we introduce the ability to use closures as annotation parameters. Closures are also a key part of what gives Groovy its functional flavor.

Closure annotation parameters

In Java, there's a limited set of types you can use as annotation parameters (String, primitives, annotations, classes, and arrays of these). But in Groovy 1.8, we're going further and let you use closures as annotation parameters – which are actually transformed into a class parameter for compatibility reasons.

Closure annotation parameters open up some interesting possibilities for framework authors! As an example, the GContracts project, which brings the "Design by Contract" paradigm to Groovy makes heavy use of annotation parameters to allow preconditions, postconditions and invariants to be declared.

Closure functional flavors

Closure composition

If you recall your math lessons, function composition may be a concept you're familiar with. And in turn, Closure composition is about that: the ability to compose Closures together to form a new Closure which chains the call of those Closures. Here's an example of composition in action:

To see more examples of Closure composition and reverse composition, please have a look at our test case.

Closure trampoline

When writing recursive algorithms, you may be getting the infamous stack overflow exceptions, as the stack starts to have a too high depth of recursive calls. An approach that helps in those situations is by using Closures and their new trampoline capability.

Closures are wrapped in a TrampolineClosure. Upon calling, a trampolined Closure will call the original Closure waiting for its result. If the outcome of the call is another instance of a TrampolineClosure, created perhaps as a result to a call to the trampoline() method, the Closure will again be invoked. This repetitive invocation of returned trampolined Closures instances will continue until a value other than a trampolined Closure is returned. That value will become the final result of the trampoline. That way, calls are made serially, rather than filling the stack.

Here's an example of the use of trampoline() to implement the factorial function:

Closure memoization

Another improvement to Closures is the ability to memoize the outcome of previous (ideally side-effect free) invocations of your Closures. The return values for a given set of Closure parameter values are kept in a cache, for those memoized Closures. That way, if you have an expensive computation to make that takes seconds, you can put the return value in cache, so that the next execution with the same parameter will return the same result – again, we assume results of an invocation are the same given the same set of parameter values.

There are three forms of memoize functions:

  • the standard memoize() which caches all the invocations
  • memoizeAtMost(max) call which caches a maximum number of invocations
  • memoizeAtLeast(min) call which keeps at least a certain number of invocation results
  • and memoizeBetween(min, max) which keeps a range results (between a minimum and a maximum)

Let's illustrate that:

Currying improvements

Currying improvements have also been backported to recent releases of Groovy 1.7, but it's worth outlining here for reference. Currying used to be done only from left to right, but it's also possible to do it from right to left, or from a given index, as the following examples demonstrate:

Native JSON support

With the ubiquity of JSON as an interchange format for our applications, it is natural that Groovy added support for JSON, in a similar fashion as the support Groovy's always had with XML. So Groovy 1.8 introduces a JSON builder and parser.

Reading JSON

A JsonSlurper class allows you to parse JSON payloads, and access the nested Map and List data structures representing that content. JSON objects and arrays are indeed simply represented as Maps and Lists, giving you access to all the GPath expression benefits (subscript/property notation, find/findAll/each/inject/groupBy/etc.). Here's an example showing how to find all the recent commit messages on the Grails project:

If you want to see some more examples of the usage of the JSON parser, you can have a look at the JsonSlurper tests in our code base.

JSON builder

Parsing JSON data structures is one thing, but we should also be able to produce JSON content just like we create markup with the MarkupBuilder. The following example:

Will create the JSON output:

You can find some more usages of the JSON builder in our JsonBuilder tests.

Pretty printing JSON content

When given a JSON data structure, you may wish to pretty-print it, so that you can more easily inspect it, with a more friendly layout. So for instance, if you want to pretty print the result of the previous example, you could do:

Which would result in the following pretty-printed output:

New AST Transformations

The Groovy compiler reads the source code, builds and Abstract Syntax Tree (AST) from it, and then puts the AST into bytecode. With AST transformations, the programmer can hook into this process. A general description of this process, an exhaustive description of all available transformations, and a guide of how to write you own ones can be found for example in Groovy in Action, 2nd Edition (MEAP), chapter 9.

Below is a list of all new transformations that come with Groovy 1.8. They save you from writing repetitive code and help avoiding common errors.


You can annotate your classes with the @Log transformation to automatically inject a logger in your Groovy classes, under the log property. Four kind of loggers are actually available:

  • @Log for java.util.logging
  • @Commons for Commons-Logging
  • @Log4j for Log4J
  • @Slf4j for SLF4J

Here's a sample usage of the @Log transformation:

You can change the name of the logger by specifying a different name, for instance with @Log('myLoggerName').

Another particularity of these logger AST transformations is that they take care of wrapping and safe-guarding logger calls with the usual isSomeLevelEnabled() calls. So when you write 'Car constructed', the generated code is actually equivalent to:


When defining variables in a script, those variables are actually local to the script's run method, so they are not accessible from other methods of the script. A usual approach to that problem has been to store variables in the binding, by not def'ining those variables and by just assigning them a value. Fortunately, the @Field transformation provides a better alternative: by annotating your variables in your script with this annotation, the annotated variable will become a private field of the script class.

More concretely, you'll be able to do as follows:

@PackageScope enhancements

The @PackageScope annotation can be placed on classes, methods or fields and is used for turning off Groovy's visibility conventions and reverting back to Java conventions. This ability is usually only needed when using 3rd party libraries which rely on the package scope visibility. When adding the @PackageScope annotation to a field, Groovy will assign package scope access to the field rather than automatically treating it as a property (and adding setters/getters). Annotating a class or method with @PackageScope will cause Groovy to revert to Java's convention of leaving the class/method as package scoped rather than automatically promoting it to public scope. The class variant can also take one or more parameters to allow nested setting of visibility of attributes within the class - see the Javadoc for more details. Recent releases of Groovy 1.7 have had a more limited version of this annotation.


The @AutoClone annotation is placed on classes which you want to be Cloneable. The annotation instructs the compiler to execute an AST transformation which adds a public clone() method and adds Cloneable to the classes implements list of interfaces. Because the JVM doesn't have a one-size-fits-all cloning strategy, several customizations exist for the cloning implementation:

  • By default, the clone() method will call super.clone() before calling clone() on each Cloneable property of the class. Example usage:
    Which will create a class of the following form:
  • Another popular cloning strategy is known as the copy constructor pattern. If any of your fields are final and Cloneable you should set style=COPY_CONSTRUCTOR which will then use the copy constructor pattern.
  • As a final alternative, if your class already implements the Serializable or Externalizable interface, you might like to set style=SERIALIZATION which will then use serialization to do the cloning.

See the Javadoc for AutoClone for further details.


The @AutoExternalizable class annotation is used to assist in the creation of Externalizable classes. The annotation instructs the compiler to execute an AST transformation which adds writeExternal() and readExternal() methods to a class and adds Externalizable to the interfaces which the class implements. The writeExternal() method writes each property (or field) for the class while the readExternal() method will read each one back in the same order. Properties or fields marked as transient are ignored. Example usage:

Which will create a class of the following form:

Controlling the execution of your code

When integrating user-provided Groovy scripts and classes in your Java application, you may be worried about code that would eat all your CPU with infinite loops, or that call methods like System.exit(0) (for the latter, check the section on compiler customizers, and particularly the SecureASTCustomizer). It would be interesting to have a wait to control the execution of that Groovy code, to be able to interrupt its execution when the thread is interrupted, when a certain duration has elapsed, or when a certain condition is met (lack of resources, etc).

Groovy 1.8 introduces three transformations for those purposes, as we shall see in the following sections. By default, the three transformations add some checks in at the beginning of each method body, and each closure body, to check whether a condition of interruption is met or not.

Note that those transformations are local (triggered by an annotation). If you want to apply them transparently, so that the annotation doesn't show up, I encourage you to have a look at the ASTTransformationCustomizer explained at the end of this article.

Cédric Champeau, our most recent Groovy committer, who implemented those features, has a very nice blog post covering those code interruption transformations.


You don't need to write checks in your scripts for whether the current thread of execution has been interrupted or not, by default, the transformation will add those checks for you for scripts and classes, at the beginning of each method body and closure body:

You can specify a checkOnMethodStart annotation parameter (defaults to true) to customize where checks are added by the transformation (adds an interrupt check by default as the first statement of a method body). And you can also specify the applyToAllClasses annotation parameter (default to true) if you want to specify whether only the current class or script should have this interruption logic applied or not.


With @TimedInterrupt, you can interrupt the script after a certain amount of time:

In addition to the previous annotation parameters we mentioned for @ThreadInterrupt, you should specify value, the amount of time to wait, and unit (defaulting to TimeUnit.SECONDS) to specify the unit of time to be used.


An example of @ConditionalInterrupt which leverages the closure annotation parameter feature, and the @Field transformation as well:

You can imagine defining any kind of condition: on counters, on resource availability, on resource usage, and more.


Provides your classes with a default toString() method which prints out the values of the class' properties (and optionally the property names and optionally fields). A basic example is here:

And here's another example using a few more options:


Provides your classes with equals() and hashCode() methods based on the values of the class' properties (and optionally fields and optionally super class values for equals() and hashCode()).


Provides a tuple (ordered) constructor. For POGOs (plain old Groovy objects), this will be in addition to Groovy's default "named-arg" constructor.


Allows you to combine @ToString, @EqualsAndHashCode and @TupleConstructor. For those familiar with Groovy's @Immutable transform, this provides similar features but for mutable objects.

By default, @Canonical gives you vanilla versions for each of the combined annotations. If you want to use any of the special features that the individual annotations give you, simply include the individual annotation as well.

You will find a great write-up on @Canonical, @ToString, @EqualsAndHashCode and @TupleConstructor on John Prystash's weblog.


Sometimes, when you want to subclass certain classes, you also need to override all the constructors of the parent, even if only to call the super constructor. Such a case happens for instance when you define your own exceptions, you want your exceptions to also have the constructors taking messages and throwable as parameters. But instead of writing this kind of boilerplate code each time for your exceptions:

Simply use the @InheritConstructors transformation which takes care of overriding the base constructors for you:

@WithReadLock and @WithWriteLock

Those two transformations, combined together, simplify the usage of java.util.concurrent.locks.ReentrantReadWriteLock, are safer to use than the synchronized keyword, and improve upon the @Synchronized transformation with a more granular locking.

More concretely, with an example, the following:

Will generate code as follows:

Alignments with JDK 7

Groovy 1.9 will be the version which will align as much as possible with the upcoming JDK 7, so beyond those aspects already covered in Groovy (like strings in switch and others), most of those "Project Coin" proposals will be in 1.9, except the "diamond operator" which was added in 1.8, as explained in the following paragraph.

Diamond operator

Java 7 will introduce the "diamond" operator in generics type information, so that you can avoid the usual repetition of the parameterized types. Groovy decided to adopt the notation before JDK 7 is actually released. So instead of writing:

You can "omit" the parameterized types and just use the pointy brackets, which now look like a diamond:

New DGM methods

  • count Closure variants
  • countBy
  • plus variants specifying a starting index
  • equals for Sets and Maps now do flexible numeric comparisons (on values for Maps)
  • toSet for primitive arrays, Strings and Collections
  • min / max methods for maps taking closures
    (also available in Groovy 1.7)
  • map withDefault{}
    Oftentimes, when using a map, for example for counting the frequency of words in a document, you need to check that a certain key exists, before doing something with the associating value (like incrementing it). Nothing really complex, but we could improve upon that with a new method, called withDefault. So instead of writing code like below:
    Thanks to the new method (also backported to 1.7), you can write the example as follows:


Slashy strings

Slashy strings are now multi-line:

This is particularly useful for multi-line regexs when using the regex free-spacing comment style (though you would still need to escape slashes):

Dollar slashy strings

A new string notation has been introduced: the "dollar slashy" string. This is a multi-line GString similar to the slashy string, but with slightly different escaping rules. You are no longer required to escape slash (with a preceding backslash) but you can use '$$' to escape a '$' or '$/' to escape a slash if needed. Here's an example of its usage:

This form of string is typically used when you wish to embed content that may naturally contains slashes or backslashes and you don't want to have to rework the content to include all of the necessary escaping. Some examples are shown below.

XML fragments with backslashes:

Better than a normal (now multi-line) slashy string where you would have to escape the slashes or a triple quote (""") GString where you would have to escape the backslashes.

Or windows pathnames containing a slash at the end:

Triple quote (""") GString requires extra escaping. Illegal for a normal slashy string - now ugly workarounds are not needed.

Or multi-line regexs when using the regex free-spacing comment style (particularly ones which contain slashes):

So, you can cut and paste most PERL regex examples without further escaping.

Or Strings which are themselves Groovy code fragments containing slashes:

Again, you can cut and paste many slashy string Groovy examples and have them in dollar slashy strings without further escaping.

Compilation customizers

The compilation of Groovy code can be configured through the CompilerConfiguration class, for example for setting the encoding of your sources, the base script class, the recompilation parameters, etc). CompilerConfiguration now has a new option for setting compilation customizers (belonging to the org.codehaus.groovy.control.customizers package). Those customizers allow to customize the compilation process in three ways:

  • adding default imports with the ImportCustomizer: so you don't have to always add the same imports all over again
  • securing your scripts and classes with the SecureASTCustomizer: by allowing/disallowing certain classes, or special AST nodes (Abstract Syntax Tree), filtering imports, you can secure your scripts to avoid malicious code or code that would go beyond the limits of what the code should be allowed to do.
  • applying AST transformations with the ASTTransformationCustomizer: lets you apply transformations to all the class nodes of your compilation unit.

For example, if you want to apply the @Log transformation to all the classes and scripts, you could do:

This will log the two messages, the one from the script, and the one from the Car class constructor, through java.util.logging. No need to apply the @Log transformation manually to both the script and the class: the transformation is applied to all class nodes transparently. This mechanism can also be used for adding global transformations, just for the classes and scripts that you compile, instead of those global transformations being applied to all scripts and classes globally.

If you want to add some default imports (single import, static import, star import, star static imports, and also aliased imports and static imports), you can use the import customizer as follows:

When you want to evaluate Math expressions, you don't need anymore to use the import static java.lang.Math.* star static import to import all the Math constants and static functions.

(G)String to Enum coercion

Given a String or a GString, you can coerce it to Enum values bearing the same name, as the sample below presents:

Maps support isCase()

Maps now support isCase(), so you can use maps in your switch/case statements, for instance:

Grape/Grab Improvements

Shorter notation for @GrabResolver

When you need to specify a special grab resolver, for when the artifacts you need are not stored in Maven central, you could use:

Groovy 1.8 adds a shorter syntax as well:

Compact form for optional Grab attributes

The @Grab annotation has numerous options. For example, to download the Apache commons-io library (where you wanted to set the transitive and force attributes - not strictly needed for this example but see the Grab or Ivy documentation for details on what those attributes do) you could use a grab statement similar to below:

The compact form for grab which allows the artifact information to be represented as a string now supports specifying additional attributes. As an example, the following script will download the commons-io jar and the corresponding javadoc jar before using one of the commons-io methods.

Storing AST node metadata

When developing AST transformations, and particularly when using a visitor to navigate the AST nodes, it is sometimes tricky to keep track of information as you visit the tree, or if a combination of transforms need to be sharing some context. The ASTNode base class features 4 methods to store node metadata:

  • public Object getNodeMetaData(Object key)
  • public void copyNodeMetaData(ASTNode other)
  • public void setNodeMetaData(Object key, Object value)
  • public void removeNodeMetaData(Object key)

Ability to customize the GroovyDoc templates

GroovyDoc uses hard-coded templates to create the JavaDoc for your Groovy classes. Three templates are used: top-level templates, a package-level template, a class template. If you want to customize these templates, you can subclass the Groovydoc Ant task and override the getDocTemplates(), getPackageTemplates(), and getClassTemplates() methods pointing at your own templates. Then you can use your custom GroovyDoc Ant task in lieu of Groovy's original one.

Support for begin() / end() methods when processing files line by line with the groovy command

A feature found in other scripting languages like Perl or Awk is to be able to have a begin / end method when processing a file line by line. The groovy command supports this mode of operation, but didn't support the begin / end methods. (this feature is actually going to be available in 1.7.11 and 1.8.1, but time ran short for inclusion in the 1.8 final release)

More concretely, if you have a text file named dummy.txt, and you want to count the number of lines it contains, you could do this on the command-line:

  • No labels