Andres Almiray (Canoo) presented this presentation on Groovy AST Transformations. It did not surprise me that most of the audience had Groovy experience given that use of Groovy ASTs is likely more appealing to those with some familiarity with Groovy already.
Almiray defined AST Transformations as ‘essentially byte code generation’ that ‘enables compile-time metaprogramming.’ He showed that Groovy has two types of AST Transformations: global and local. The focus of today’s presentation is on global AST transformations.
The AST Transformations framework was added to Groovy years ago, but things were made much easier in Groovy 1.7. Almiray covered the Delegate Transformation (
@Delegate annotation) in Groovy allows the compiled code to have all of the public methods of the field that was explicitly delegated to. Almiray explained that
@Delegate works with interfaces as well as classes. Almiray also explained that any new method defined will take precedent over any delgate method of the same signature. Similarly, the first delegate encountered takes precedent over same method signature of other delegates.
Almiray then covered
@Singleton and the Singleton Transformation. Almiray stated that the singleton implemented with this transformation meets the definition of a safe singleton described in Josh Bloch’s Effective Java.
@Immutable (the Immutable Transformation) was covered next. Just as the
@Singleton transformation automatically implemented all necessary rules for singletons, the
@Immutable transformation implements the rules for immutable. Almiray noted that there are different exceptions for attempts to set a property on an immutable Groovy class via property set versus method set.
The next Groovy AST transformation to be covered was
@Category (the Category Transformation). This was the first covered transformation that requires usage within Groovy code (not within Java code) to be fully used. The Mixin Transformation (
@Mixin) was also covered.
Almiray moved onto coverage of
@Grab (Grab Transformation), one which I have posted about before.
@Grab is useful for downloading dependencies at runtime. I like it for the same reason that Almiray mentioned: ‘it’s perfect for self-contained scripts.’
Almiray introduced the
@Synchronized (Synchronized Transformation) as a Groovier way to specify synchronized blocks. Almiray covered the
@Lazy (Lazy Transformation), which is used to only initialize values when actually needed (when first used). Almiray pointed out Groovy’s ability to access classes’ private fields and cautioned that this should only be used for unit testing and only when absolutely necessary in production.
Almiray demonstrated use of
@Newify (Newify Transformation) before showing a code sample using
@Bindable (Bindable Transformation), which he stated was added to Groovy to make use of Swing easier. The transformation makes a class observable and removes the need to write all the code for explicitly doing this. The
@Vetoable transformation similarly makes it easier to veto a property change.
Almiray covered some of my favorite and most often-used Groovy transformations: @ToString (see my post), @EqualsAndHashCode (see my post), @TupleConstructor (see my post), or the combination of them all (@Canonical – see my post).
Following coverage of
@Canonical and its constituent transformations, Almiray moved onto covering
@IndexedProperty (related post). He then listed several others without code samples:
@ThreadInterrupt, @PackageScope (‘gain back package-level access specificity in Groovy’),
@WithWriteLock, and @Field (‘mostly used inside scripts’).
I was happy to see Almiray mention the addition of @TypeChecked to support ‘static Groovy!’ He referenced a later presentation on new features of Groovy 2.0 to get more details.
Although I was already familiar with a large percentage of the Groovy AST transformations covered in this presentation, it was still worthwhile to attend and learn of or be reminded of other useful transformations that are available.
Don’t forget to share!
Reference: JavaOne 2012: A Walk Through of Groovy’s AST Transformations from our JCG partner Dustin Marx at the Inspired by Actual Events blog.
Author David Gassner explores Java SE (Standard Edition), the language used to build mobile apps for Android devices, enterprise server applications, and more!
The course demonstrates how to install both Java and the Eclipse IDE and dives into the particulars of programming. The course also explains the fundamentals of Java, from creating simple variables, assigning values, and declaring methods to working with strings, arrays, and subclasses; reading and writing to text files; and implementing object oriented programming concepts. Exercise files are included with the course.