Java Annotations

Self-Descriptive Coding in java.

Java has introduced the feature called annotation through which elements of a program can be marked to contain some Meta data. This Meta data may be available at compile time or at running time. Now it is possible to provide some information for methods, fields, classes etc. that will be available at processing time. You can annotate your method telling to calling method how to call your method. You can annotate your class to tell something to class loader how to cerate the object of class and for what the object should be used. You can declare fields in you class those may be annotated to get their value from specified source.

New version of java and j2ee has been updated to use annotations. Like EJB, webs services, JPA(java persistence API) etc. New version EJB3.x has been simplified to create the EJB without using any XML file. Because the information required to EJB container are provided by the annotation. EJB programmer annotates his class to provide the JNDI name for EJB. In JPA, programmer annotates their coding to map the object into table. There is no need to define how to map Object data into Database.

How to use it
There are two things one is annotation and second is annotation type. Annotation is the marker entity and annotation-type is declaration about marker entity.

You can create annotation type using @ sign followed by interface keyword and annotation declarations contents. Each method declaration defines an element of the annotation type. Method declaration does not contain any parameter and throws clause. The methods have some limited return types. Primitives, String ,Class, enums, annotation, and arrays of preceding types according to the specification of annotation in JDK 1.5.


//Defining annotation type
import java.lang.annotation.*;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@ interface A1{
public String author();
public double version();
}

In the above example
Package java.lang.annotation is imported to access the Target, Retention annotations etc.
Target is being used to define that which portion of program will be annotated by this annotation. Like for class, method or field.
Retantion defines the availability of the annotation. It decides at which time annotation will be discarded, for example run time, compile time etc.
@interface is declaring the annotation A1
Methods author() and version() are elements of annotation A1.


Now following program is showing the use of above declared annotation.

//annotating class using annotation
@A1(author="Hemraj", version=1.0)
class UseAnno1{
public void print(String s){
System.out.println("Hello "+s.toUpperCase());
}
}

Here we used the annotation A1 to provide author name and version for the class. We used the following syntax to use annotation.

@annotation (element1=val1, element2=value2…..)

There may more syntax for deferent types of annotations. We provided value “Hemraj” to the element author and value 1.0 to element version. These elements will available with values at the processing time. We can process annotation to get elements and values at run time.



See the following program that is processing annotation.

class Anno1{
public static void main(String ar[]){
UseAnno1 a1=new UseAnno1();
Class c=a1.getClass();
A1 anno=(A1)c.getAnnotation(A1.class);
System.out.println("Author :"+anno.author());
System.out.println("Version :"+anno.version());
}
}

OUTPUT is :
Author :Hemraj
Version :1.0


The above simple program gets the class of object a1 and then get the annotation by calling getAnnotation() method. This method will take the annotation declaration to create proxy object and it return Object type so we have to cast it as A1 type and the reference of annotation is hold into anno reference variable.

Then we called author() method to get value of author element and version() method to get the value of version element from the object referenced through anno reference variable.