Hi all, my name is Hubert A. Klein Ikkink. Not a very common name, right? To make things easier I just picked the first letters of my firstname and surname and came up with haki. So there you have it, now I am also known as Mr. Haki or mrhaki for short. You can read more blog postings at www.mrhaki.com. I am a passionate Groovy and Java developer based in Tilburg, The Netherlands. My goal is to write clean, elegant, user-centered and high quality software. You can find me on Google+ and Twitter. Hubert is a DZone MVB and is not an employee of DZone and has posted 151 posts at DZone. You can read more from them at their website. View Full User Profile

Groovy Goodness: Combining Annotations with AnnotationCollector

02.19.2013
| 3779 views |
  • submit to reddit

Groovy 2.1 introduces a new annotation to group multiple annotations and define an alias for the group. The new @AnnotationCollector annotation is an AST transformation. If we repeatedly have to add multiple annotations we can now create an alias for the multiple annotations and use it in our code.

We can define the group of annotations as an argument for the @AnnotationCollector annotations. For example in the next sample code we create an annotation to apply the @EqualsAndHashCode and @ToString annotations and use the alias Simple. We pass a list of annotations to the @AnnotationColletor:

@AnnotationCollector([EqualsAndHashCode, ToString])
@interface Simple {}


@Simple
class User {
    String username
    int age
}

def user = new User(username: 'mrhaki', age: 39)
assert user.toString() == 'User(mrhaki, 39)'

// We still have 2 annotations:
assert User.class.annotations.size() == 2


// We can use the attributes from the 
// grouped annotations.
@Simple(excludes = 'street') 
class Address {
    String street, town
}

def address = new Address(street: 'Evergreen Terrace', town: 'Springfield') 
assert address.toString() == 'Address(Springfield)'

Notice we can also use the attributes from the grouped annotations. If an attribute cannot be mapped to the existing attributes of the grouped annotations we get an error. We can write custom code to handle new attributes in a so-called processor class. In the processor we can define how we want to handle the attributes. In the following sample we define a custom attribute dontUse and we use the value for the excludes attribute of the grouped annotations:

import org.codehaus.groovy.transform.*
import org.codehaus.groovy.ast.*
import org.codehaus.groovy.control.*

class SimpleProcessor extends AnnotationCollectorTransform {

    public List<AnnotationNode> visit(AnnotationNode collector, 
                                      AnnotationNode aliasAnnotationUsage, 
                                      AnnotatedNode aliasAnnotated, 
                                      SourceUnit source) {
                                      
        // Get attributes and attribute value for dontUse.
        def attributes = aliasAnnotationUsage.getMembers()
        def dontUse = attributes.get('dontUse')
        attributes.remove('dontUse')
        
        if (dontUse) {
            // Assign value of dontUse to excludes attributes.
            aliasAnnotationUsage.addMember("excludes", dontUse)
        }
        
        super.visit(collector, aliasAnnotationUsage, aliasAnnotated, source)
    }    
    
}

new GroovyShell(this.class.classLoader).evaluate '''
import groovy.transform.*

@AnnotationCollector(value = [EqualsAndHashCode, ToString], processor = 'SimpleProcessor')
@interface Simple {}


@Simple(dontUse = 'age')
class User {
    String username
    int age
}

def user = new User(username: 'mrhaki', age: 39)
assert user.toString() == 'User(mrhaki)'
'''

Another way to define an alias for a group of annotations is to simply define an annotation, add the annotations we want to group and as last annotation we add the @AnnotationCollector. In the next sample we combine the @Grapes and @Slf4j annotations into the alias LoggingSlf4j:

// Add dependencies for Slf4j API and Logback
import org.slf4j.*
import groovy.util.logging.Slf4j
import groovy.transform.*

@Grapes([
    @Grab(group='org.slf4j', module='slf4j-api', version='1.6.1'),
    @Grab(group='ch.qos.logback', module='logback-classic', version='0.9.28')
])
@Slf4j
@AnnotationCollector
@interface LoggingSlf4j {}


// Use annotation to 'grab' dependencies and
// inject log field into the class.
@LoggingSlf4j
class HelloWorldSlf4j {
    def execute() {
        log.debug 'Execute HelloWorld.'
        log.info 'Simple sample to show log field is injected.'
    }
}

def helloWorld = new HelloWorldSlf4j()
helloWorld.execute()  
// Output:
// 05:40:57.724 [Thread-19] DEBUG HelloWorldSlf4j - Execute HelloWorld.
// 05:40:57.724 [Thread-19] INFO  HelloWorldSlf4j - Simple sample to show log field is injected.

More info and samples are also available on the blog of Andres Steingress.

Written with Groovy 1.2.



 

Published at DZone with permission of Hubert Klein Ikkink, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)

Comments

Hubert Klein Ikkink replied on Tue, 2013/02/19 - 9:04am

Errata: Code was written in Groovy 2.1 not in 1.2 ;-)

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.