Java annotations provide some information about the code, but do not directly affect the content of the code it annotates. In this tutorial, we will learn Java annotations, how to customize annotations, their use and how to parse annotations through reflection.
Java1.5 introduced annotations, which are currently widely used in many java frameworks, such as Hibernate, Jersey, and Spring. Annotations are embedded into the program as metadata of the program. Annotations can be parsed by some parsing tools or compilation tools. We can also declare annotations to have an effect during compilation or execution.
Before using annotations, program source data only passed through java comments and javadoc, but the functions provided by annotations far exceed these. Annotations not only contain metadata, they can also be used during program running. The annotation interpreter can determine the execution order of the program through annotations. For example, in Jersey webservice we add the **PATH** annotation in the form of a URI string to the method, then during the running of the program, the jersey interpreter will determine the method to call the given URI.
Create Java custom annotations
Creating a custom annotation is similar to creating an interface, but the interface keyword of the annotation needs to start with the @ symbol. We can declare methods for annotations. Let's first look at an example of annotation, and then we'll discuss some of its features.
package com.journaldev.annotations;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
String author() default 'Pankaj';
String date();
int revision() default 1;
String comments();
}Annotation methods cannot have parameters;
The return value type of annotation methods is limited to: basic types, String, Enums, Annotation or Arrays of these types;
annotation methods can have default values;
the annotations themselves can contain meta-annotations, which are used to annotate other annotation.
There are four types of meta-annotations:
1. @Documented - Indicates that the element with this annotation can be documented by tools such as javadoc. This type should be used to annotate types that affect client declarations using annotated elements. If a declaration is annotated with Documented, this type of annotation is used as the public API of the annotated program member.
2. @Target——Indicates the range of program elements that this type of annotation can annotate. The value of this meta-annotation can be TYPE, METHOD, CONSTRUCTOR, FIELD, etc. If the Target meta-annotation is not present, the defined annotation can be applied to any element of the program.
3. @Inherited - Indicates that the annotation type is automatically inherited. If the user queries this meta-annotation type in the current class and the declaration of the current class does not contain this meta-annotation type, then the parent class of the current class will also be automatically queried to see if there is an Inherited meta-annotation. This action will be executed repeatedly until this annotation type is known. is found, or the top-level parent class is queried.
4.@Retention——Indicates the length of time that the Annotation is retained. The values of RetentionPolicy are SOURCE, CLASS, and RUNTIME.
Java built-in annotations
Java provides three built-in annotations.
1. @Override - When we want to override a method in the parent class, we need to use this annotation to tell the compiler that we want to override this method. In this way, the compiler will prompt an error message when the method in the parent class is removed or changed.
2. @Deprecated - We should use this annotation when we want the compiler to know that a certain method is deprecated. Java recommends the use of this annotation in the javadoc, and we should provide why this method is deprecated and alternatives.
3. @SuppressWarnings - This just tells the compiler to ignore specific warning messages, such as using native data types in generics. Its retention policy is SOURCE (Translator's Note: valid in source files) and is discarded by the compiler.
Let’s look at an example of java’s built-in annotations and refer to the custom annotations mentioned above.
package com.journaldev.annotations;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
public class AnnotationExample {
public static void main(String[] args) {
}
@Override
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 1)
public String toString() {
return 'Overriden toString method';
}
@Deprecated
@MethodInfo(comments = 'deprecated method', date = 'Nov 17 2012')
public static void oldMethod() {
System.out.println('old method, don't use it.');
}
@SuppressWarnings({ 'unchecked', 'deprecation' })
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 10)
public static void genericsTest() throws FileNotFoundException {
List l = new ArrayList();
l.add('abc');
oldMethod();
}
}I believe this example is self-explanatory and can show its application in different scenarios.
Java annotation parsing
We will use reflection technology to parse the annotations of java classes. Then the RetentionPolicy of the annotation should be set to RUNTIME. Otherwise, the annotation information of the java class will not be available during execution, and we will not be able to get any annotation-related data from it.
package com.journaldev.annotations;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
public class AnnotationParsing {
public static void main(String[] args) {
try {
for (Method method : AnnotationParsing.class
.getClassLoader()
.loadClass(('com.journaldev.annotations.AnnotationExample'))
.getMethods()) {
// checks if MethodInfo annotation is present for the method
if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
try {
// iterates all the annotations available in the method
for (Annotation anno : method.getDeclaredAnnotations()) {
System.out.println('Annotation in Method ''+ method + '' : ' + anno);
}
MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
if (methodAnno.revision() == 1) {
System.out.println('Method with revision no 1 = '+ method);
}
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
} catch (SecurityException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}Running the above program will output:
Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012) Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString() Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated() Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012) Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod() Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)
This is the entire content of this tutorial, I hope you can learn something from it.
The above is the content of Java annotation tutorial and custom annotations. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!