Before annotations almost all configuration data had to be kept in XML format. And as the application grew, the number and complexity of its XML-files had been increasing exponentially. They called it XML hell.
And now when we have annotations we can keep the configuration of the code right with it. Besides annotations are tested and verified by the compiler.
But the use of annotations is not limited to configuration, annotations allow you to get rid of the boilerplate code (e.g. cross-cutting concerns such as transactions and security).
The boon of annotations can be very easily noted using Hibernate Annotation package, Spring 2.5 and newer, Seam. But how do they write the annotations of their own?
So here is the definition of our annotation @Testing:
package com.test.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Testing { }
As you can see this definition is not much unlike of the definition of an interface. And really it compiles to the class file as any other Java interface. As you can see the annotation definition requires @Target and @Retention annotations:- @Target defines where you can use your annotation. In this example it can be used only with methods. Here are all possible values and places where you can use annotations:
- TYPE - class, interface (including annotation type), or enum declaration
- FIELD - field declaration (includes enum constants)
- METHOD - method declaration
- PARAMETER - parameter declaration
- CONSTRUCTOR - constructor declaration
- LOCAL_VARIABLE - local variable declaration
- ANNOTATION_TYPE - annotation type declaration
- PACKAGE - package declaration
- @Retention defines when the annotation can be available:
- SOURCE - in the source code (discarded by the compiler)
- CLASS - in the class files (not retained at run time). This is the default behavior.
- RUNTIME - at run time (can be read reflectively)
We will use proxy pattern to allow our processor intercept the calls to the methods annotated with @Testing. Java provides implementation of the proxy with the java.lang.reflect.Proxy. It is very powerful tool but unfortunately it does not provide possibility to create proxies just for the class, you have to provide the list of interfaces to create the proxy (if you need to proxy classes and not just interfaces then you should use CGLib).
So let's create the annotation processor:
package com.test.annotation.processor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import com.test.annotation.Testing;
public class TestingInvocationHandler implements InvocationHandler {
private Object proxied;
public TestingInvocationHandler(Object proxied) {
this.proxied = proxied; }
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Method m = proxied.getClass().getMethod(method.getName(), method.getParameterTypes());
if (m.isAnnotationPresent(Testing.class)) {
System.out.println("\tIn the annotation processor");
}
return method.invoke(proxied, args);
}
}
The annotation processor implements InvocationHandler interface. This interface is responsible for handling the proxy object invocation. As you can see we only print additional line before invoking the original method.
Here is the helper class with the static method to get the proxy object:
package com.test.annotation.processor;
import java.lang.reflect.Proxy;
public class TestingProxy {
public static Object getNewProxy(Object proxied, Class<?> interfaze) {
Object proxy = Proxy.newProxyInstance(
TestingInvocationHandler.class.getClassLoader(),
new Class[] {interfaze},
new TestingInvocationHandler(proxied));
return proxy;
}
}
Let's define the interfacepackage com.test.service;
public interface Observable {
void print1();
void print2();
}
and the class of the proxied objectspackage com.test.service;
import com.test.annotation.Testing;
import com.test.annotation.processor.TestingProxy;
public class PrintService implements Observable {
private static Observable instance;
private PrintService(){
}
public static Observable getInstance() {
if (instance == null) {
instance = (Observable) TestingProxy.getNewProxy(new PrintService(),
Observable.class);
}
return instance;
}
@Testing
public void print1() {
System.out.println("1 - Text in annotated method");
}
public void print2() {
System.out.println("2 - Just ususal text");
}
}
This class is implemented as a simple singleton and uses the proxy object in getInstance() method. Also this class implements both methods of the interface. One of this methods is annotated and the other is not.Finally let's create the class with the main method:
package com.test;
import com.test.service.Observable;
import com.test.service.PrintService;
public class Application {
public static void main(String[] args) {
Observable printService = PrintService.getInstance();
printService.print1();
printService.print2();
}
}
That's all.
