1. preface
A few years ago, our project was still running on structs 2, and once I asked a colleague if he knew
Spring Boot, colleagues said it was developed using annotations. Although this answer is not entirely correct, objectively speaking, the most eye-catching thing about Spring Boot for those who have just been exposed to it is annotations. So today let's take a look at the core function of the Java language-annotations.
2. What are annotations?
public @interface Anno {
}
The above is the simplest annotation statement. It can be annotated to classes, interfaces, methods, and variables. Assign additional metadata to the source code to which it is bound by adding comments to a method, interface, class, or field.
3. Purpose of annotations
By annotating we can inform the compiler about warnings and errors, manipulating source code at compile time, modifying or checking behavior at run time. Jdk provides 5 basic annotations built-in to handle code inspections.
- @Override to mark the behavior of the method to override or replace an inherited method. If you override a parent method without this annotation, some warnings will be triggered.
- @SuppressWarnings means that we want to ignore certain warnings in some code. For example, ignoring potential type-unsafe conversion warnings unchecked.
- @Deprecated is used to indicate that classes and methods are outdated and is not recommended. If you force the compiler, it will warn you at compile time.
- @Safevarargs suppresses "heap pollution" warnings. "Heap pollution" refers to the type problem that arises when an object without generics is assigned to a variable with generics. If you don't want to see the warning, you can use this annotation to suppress it.
- @FunctionalInterface java 8 adds annotations that can only be applied to interfaces to identify that the interface is a functional interface. A functional interface in java means that the interface can only have one abstract method. If an interface is decorated with this annotation, adding a second abstract method will not pass compilation.
Annotations can pass some metadata to the logic you write. For example,@RequestMapping, a common annotation in Spring Mvc, can pass a path path through the value parameter. Spring Mvc determines whether to route to the path by matching the requested path. Currently, a large number of frameworks rely on annotations, such as Spring, hibernate, dubbo, etc.
4. Meta-annotation
Meta-annotations are annotations that can be applied to other annotations. To enhance or configure the mechanism for target annotations. Jdk currently provides 5 meta annotations. If you need to develop custom annotations, be sure to familiarize yourself with them:
- @Retention can only be used to modify annotations to specify how long the modified annotations can be retained. Three strategies are defined:
- RetentionPolicy.SOURCE The modified annotations under this policy can only exist in the source code and are discarded after compilation. The modified annotations cannot be obtained through reflection.
- RetentionPolicy.CLASS Comments modified under this policy are compiled into a bytecode file. However, the JVM cannot retrieve the decorated annotations. This is a default value that will be specified by default when the annotation you declare does not add any retention policies.
- RetentionPolicy.RUNTIME modified annotations under this policy can not only be compiled into bytecode files. And the JVM can also retrieve annotations modified by this annotation. Moreover, program coding can also use reflection to obtain some meta information of the annotation modified by the annotation.
- @Target is used to specify the type of decoration target for the decorated annotation. If a comment specifies the target types that can be decorated, only the specified types can be decorated. Defined by the enumeration ElementType.
- TYPE can only modify classes, interfaces, and enumerations.
- FIELD can only modify member variables, including constants within the enumeration.
- METHOD can only modify methods.
- PARAMETER can only modify parameters.
- Constructor can only modify constructors.
- LOCAL_VARIABLE can only modify local variables.
- ANNOTATION_TYPE can only modify annotations.
- PACKAGE can only modify package definitions. That is, in package-info.java
- TYPE_PARAMETER java 8 adds a new indication that this annotation can be written in the declaration statement of type parameters. Type parameter declarations such as: ,
- TYPE_USE java 8 's new annotations can be used anywhere types are used.
- @Documented annotations modified by this annotation can be extracted into documents by the javadoc tool.
- @Inherited annotations modified by this annotation are inherited. There are some important points to note here. First of all, this inheritance is reflected between classes rather than interfaces, and annotations must be visible to the JVM. That is,@Retention is RetentionPolicy.RUNTIME only works.
- @Repeatable java 8 added. Previously, the same annotation could only appear once on the same element.@ Repeatable allows an annotation to appear multiple times on an element.
5. custom annotation
Custom annotations are similar to custom interfaces, but there are some differences. In actual development, you need to make meta-annotations on custom annotations. Member variables in the annotations are declared in a parameterless abstract method. Not all types of member variables are supported. Currently, only the following types are supported:
- All basic types (int,float,boolean,byte,double,char,long,short)
- String
- Class (e.g.: Class?& gt; or Class)
- enum java enumeration
- Annotation
Let's customize a comment below:
/**
* Declare a comment that can be marked on classes, interfaces, enumerations, and methods.
* And the JVM Runtime is visible and can generate documents
*
* @author Dax
* @since 17 :27 2019/9/4
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Anno {
/**
* If the method name is value and the annotation declaration only needs to declare the value attribute,
* value can be omitted, @Anno("anno") is equivalent to @Anno(value="anno")
*
* @return the string
*/
String value();
/**
* A property of type String with a default value.
* If name is not explicitly declared, the default value is "".
* Declare default values Declare using default + default value
*
* @return the string
*/
String name() default "";
/**
* A Class type attribute with no default value. Other support types are no longer cited
*
* @return the class
*/
Class<?& gt; clazz();
}How to get metadata in annotations
All annotations are subclasses of java.lang.annotation.Annotations. Only annotations with RetentionPolicy of RUNTIME can be obtained through reflection. The AnnotatedElement interface is provided in the reflection package to process captable annotations on elements. This interface is the parent interface of program element objects such as Class, Method, Constructor, etc. That is to say, as long as you can obtain the program element object, you can process its existing annotations. The main methods are:
- boolean isAnnotationPresent(Class<? extends Annotations annotationClass) determines whether an annotation of type annotationClass exists.
- T getAnnotations (Class annotationClass) Returns the corresponding annotation if there is an annotation of the type specified by the parameter (annotationClass) on the current element, otherwise it returns null.
- Annotations [] getAnnotations() returns all annotations on this element. If the element is not annotated, the return value is an array of length 0. Callers of this method are free to modify the returned array; it does not affect the arrays returned to other callers.
- T[] getAnnotationsByType(Class annotationClass) Returns the annotation associated with the element. If there is no annotation associated with this element, the return value is an array of length 0. This method differs from getAnnotations (Class) in that it detects whether its arguments are of a repeatable annotation type (JLS 9.6), and if so, attempts to find one or more annotations of that type through the "looking through" container annotation. Callers of this method are free to modify the returned array; it does not affect the arrays returned to other callers. Refer to @Repeatable.
- T getDeclaredAnnotation(Class annotationClass) Returns the corresponding annotation if the type specified in the parameter exists directly on the current element, otherwise it returns null. This method ignores inherited annotations. (Returns null if comments are not displayed directly on this element.)
- T[] getDeclaredAnnotationsByType(Class annotationClass) gets duplicate annotations but ignores inherited annotations.
- Annotations [] getDeclaredAnnotations() differs from the annotations above in that duplicate annotations cannot be obtained.
Basically, after learning the method of this interface, you can know how to obtain the metadata of annotations. Let's write an example below, using the Anno annotation above as an example:
/**
* Class marked with annotations
**/
@Anno("hello")
public class Foo {}
/**
* By getting Foo's Class class,
* Then you can get the value of value according to the methods introduced above
* @author dax
* @since 2019/9/4 22:17
*/
public class Main {
public static void main(String[] args) {
Anno annotation = Foo.class.getAnnotation(Anno.class);
String value = annotation.value();
System.out.println("value = " + value);
}
}
summary
Today we have systematically summarized annotations, and I believe you have a systematic understanding of annotations. In fact, annotations can also do some fancy operations, such as the lombok framework. We will introduce relevant annotation technologies later and pay more attention to them.
English 
Chinese
Comments0