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, the use of annotations and how to parse annotations through reflection.
Java 1.5 introduced annotations, and annotations are widely used in many current Java frameworks, such as Hibernate, Jersey, and Spring. Annotations are embedded in the program as metadata of the program. Annotations can be parsed by some parsing tools or compilation tools. We can also declare that annotations have an effect during compilation or execution.
Before annotations are used, the source data of the program is only through java annotations and javadoc, but the functions provided by annotations far exceed these. Annotation not only contains metadata, it can also be used in the running process of the program, and the annotation interpreter can fix the execution order of the program through the annotation. For example, in Jersey webservice, we add a PATH annotation in the form of a URI string to the method , then the jerser interpreter will determine the method to call the given URI during the running of the program.
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 take a look at the annotation example first, and then we will discuss some of its characteristics.
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();
}- The annotation method cannot have parameters;
- The return value type of the annotation method is limited to: basic type, String, Enums, Annotation or an array of these types;
- Annotation methods can have default values;
- The annotation itself can contain meta-annotations, which are used to annotate other annotations.
There are four types of meta annotations:
@ 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 customer use of annotated element declarations. If a declaration is annotated with Documented, this type of annotation is used as the public API of the marked program member.
@Target ——Specify the range of program elements that can be annotated by this type of annotation. The value of this meta-annotation can be TYPE, METHOD, CONSTRUCTOR, FIELD, etc. If the Target meta-annotation does not appear, then the defined annotation can be applied to any element of the program.
@Inherited -Indicates that the annotation type is automatically inherited. If the user queries the meta-annotation type in the current class and the declaration of the current class does not contain this meta-annotation type, then it will also automatically query whether there is an Inherited meta-annotation in the parent class of the current class. This action will be repeated to know the annotation type Was found, or queried to the top-level parent class.
@Retention ——Specifies the length of time the Annotation is retained. The value of RetentionPolicy is SOURCE, CLASS, RUNTIME.
Java built-in annotations
Java provides three built-in annotations.
@Override -When we want to override the method in the parent class, we need to use this annotation to inform 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.
@Deprecated ——When we want the compiler to know that a method is not recommended, we should use this annotation. Java recommends the use of this annotation in the javadoc, we should provide why this method is not recommended and alternative methods.
@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 the source file) and is discarded by the compiler.
Let's look at an example of Java built-in annotations, 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 can be self-explanatory and can show the application in different scenarios.
Java annotation analysis
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 be unavailable during execution, so we can't 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 whole content of this tutorial, I hope you can learn something from it.
At last
Reply to the data by private message to receive a summary of Java interview questions from a major manufacturer + Alibaba Taishan manual + a learning guide for knowledge points + a summary of Java core knowledge points in a 300-page pdf document!
The content of these materials are all the knowledge points that the interviewer must ask during the interview. The chapter includes many knowledge points, including basic knowledge, Java collections, JVM, multi-threaded concurrency, spring principles, microservices, Netty and RPC, Kafka , Diary, design pattern, Java algorithm, database, Zookeeper, distributed cache, data structure, etc. 