Over a million developers have joined DZone.

Groovy Goodness: Combining Annotations with AnnotationCollector

· Java Zone

Learn more about the advantages of moving from a monolithic to microservices architecture.  Brought to you in partnership with IBM.

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.



 

From Idea to Application gives you the architecture to quickly build, manage and run a range of applications (web, mobile, big data, new smart devices, etc.) on an open-standard, cloud-based platform. See why developers are using IBM Bluemix. Brought to you in partnership with IBM.

Topics:

Published at DZone with permission of Hubert Klein Ikkink, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

The best of DZone straight to your inbox.

SEE AN EXAMPLE
Please provide a valid email address.

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.
Subscribe

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}