Java Annotations: Explored & Explained--转载

Note the ‘@’(AT) symbol in front of the ‘interface’ keyword. This is the syntax used to declare an annotation. This is called an?annotation interface. The methods of the interface correspond to the elements of the annotation.?paramName()?– This is the only element our annotation declaration consists of. It stores the name of the annotated field to display it in a message while processing. Note that the declaration looks like a function declaration. Actually,that is what it is.?@interface?actually declares a Java interface whose implementation is provided by the objects that use the annotation. Annotation processors receive the objects that use/implement the annotation and they call annotation interface methods to retrieve the annotation elements. In our case,the?NullValueValidateAnnotationProcessor?would receive the object of the class that has some fields annotated using the?NullValueValidate?annotation. This processor would then call the?paramName()?method to retrieve the value of this annotation element.

We use 3 of the Java provided Annotations to annotate the properties of our declaration. These are alternatively referred to as the?Built-In Annotations?and are used for?‘Annotating an Annotation’. (Well,there are much tougher tongue twisters than this).?@Documented?– Indicates that the annotation declaration has to be included while creating the docs for this project using?JavaDocs. By default,Annotations are excluded from the documentation generated using the?javadocscommand.?@Target?– Indicates the target elements in your java program to which the annotation shall be applied. It can either the Field,Method,Class or the whole Package itself. Our?NullValueValidateannotation shall be applicable to only class fields. Here are the possible values taken by this Enum –

• TYPE – Applied only to Type. A Type can be a Java class or interface or an Enum or even an Annotation.
• FIELD – Applied only to Java Fields (Objects,Instance or Static,declared at class level).
• METHOD – Applied only to methods.
• PARAMETER – Applied only to method parameters in a method definition.
• CONSTRUCTOR – Can be applicable only to a constructor of a class.
• LOCAL_VARIABLE – Can be applicable only to Local variables. (Variables that are declared within a method or a block of code).
• ANNOTATION_TYPE – Applied only to Annotation Types.
• PACKAGE – Applicable only to a Package.

@Retention?- Indicates the retention policy to be used for the annotation. In simple words,for long would we retain the annotation. There are three possible values –

• SOURCE – Annotations are to be discarded by the compiler.
• CLASS – Annotations are to be recorded in the class file by the compiler but need not be retained by the VM at run time. This is the default behavior.
• RUNTIME – Annotations are to be recorded in the class file by the compiler and retained by the VM at run time,so they may be read reflectively.

We have set the?RetentionPolicy?to be?RUNTIME?since we plan to process the annotations at runtime of the program.@Target?and?@Retention?are also called Meta-Annotations.Annotation Processing Tool

An annotation processor tool,parses the object it receives and takes programmed actions on finding the annotations it is processing in the object under scrutiny. Here is the annotation processor for our previously declared annotation –NullValueValidate.

Most of the code is self explanatory with comments that it has. Please refer the code for detailed understanding of the same. Basically,it has a static method called?processAnnotations?that takes the object of the class which contains annotations that need to be processed. We then use Java Reflection API to process each of the Field in this received object parameter and take necessary actions of null value validation whenever we find a?NullValueValidate?Annotation on the field. If a null value is found,we throw the?NullPointerException?or we print the value on the console.

Annotation UsagePlease refer the following code that uses the?NullValueValidate?annotation that we just implemented. It also uses the?NullValueValidateAnnotationProcessorto process the declared annotations on its field at runtime by calling it from its constructor. Also do note that the annotations are used in a similar fashion as access modifiers like private or public with the variable/field declarations. Usually a newline is entered for better readability of the code. Else,the annotation can very well exist in the same line as the variable/field declaration. The name of the annotation is preceded by an ‘@’(AT) symbol.

Output

Conclusion

I had a lot of fun doing this sample annotation program and now I have implemented many custom made Annotations to load properties from property files,validations of database field lengths,etc. Annotations greatly reduces the verbosity of the code thus making it much simpler and readable. Annotations can be used for logging,generating code dependent deployment descriptors and other mechanical and repetitive jobs. I had a lot of fun compiling this article for you guys. I hope you benefit from it.

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!