Java之注解解析

转载：https://blog.csdn.net/l1028386804/article/details/80275085

一、注解的基本概念

Java 注解就像修饰符一样，可以用于从java代码中抽取文档、跟踪代码中的依赖性或者在编译时做检查。注解可以被应用在包、类、方法、成员变量、参数和本地变量的声明中。我们大多数人最先接触的注解就是@Override。

注解的工作原理就是，先使用注解修饰java代码，然后另一块叫做注解处理器的代码会解析这段注解和被修饰的代码并做相应的处理。

二、JDK内置的标准注解

JavaSE中内置了三个标准注解，都是定义在java.lang中，它们是：

1. @Override:用于修饰子类的方法覆盖了父类中的方法；
2. @Deprecated:用于修饰已经过时了的方法，不推荐使用的方法；
3. @SuppressWarnnings:告诉java编译器禁止编译警告。

2.1 @Override

@Override很简单，只是一个标记，用于标注一个方法。它表示，被它标注的方法覆盖了父类的方法。如果一不小心，子类的方法名写错了，有了@Override之后，编译时会报错。也就是说被@Override标注的方法如果没有覆盖父类的方法，编译时报错。

2.2 @Deprecated

@Deprecated也是一个标记注解，用于修饰一个方法。它表示此方法不推荐使用。无论是继承、覆盖或直接使用此方法，编译器都会给出警告。

2.3 @SuppressWarnings

字面翻译就是抑制警告，它用于告诉编译器，对被标注的这句代码不要给出特定的警告。

@SuppressWarnings有一些参数用于表示特定的警告：

1. deprecation:不要给出“不赞成使用的类或方法的警告”；
2. unchecked:不要给出“类型转换时警告”；
3. fallthrough:不要给出”switch语句块没有break的警告”；
4. path:不要给出“不存在的路径”的警告；
5. serial:不要给出“可序列化类缺少serialVersionUID”的警告；
6. finally:不要给出“finally语句块不能正常完成”的警告；
7. all:不要给出以上所有情况的警告。

三、 自定义注解

java允许我们自己定义注解，它提供了元注解用于自定义注解。

3.1 元注解

java提供元注解的目的就是让开发者自定义注解，元注解负责注解自定义注解。

1. @Target；
2. @Retention；
3. @Documented；
4. @Inherited。

Java5.0定义了4个元注解。接下来，分别分析这四个元注解：

3.1.1 @Target

@Target用来说明自定义注解可以用在什么地方，其ElementType取值有： 
1. CONSTRUCTOR:用于描述构造器 
2. FIELD:用于描述域 
3. LOCAL_VARIABLE:用于描述局部变量 
4. METHOD:用于描述方法 
5. PACKAGE:用于描述包 
6. PARAMETER:用于描述参数 
7. TYPE:用于描述类、接口(包括注解类型) 或enum声明

使用示例：@Target(ElementType.FIELD)

3.1.2 @Retention

@Retention用来描述自定义注解的生命周期，其RetentionPoicy取值有： 
1. SOURCE:在源文件中有效 
2. CLASS:在class文件中有效 
3. RUNTIME:在运行时有效

使用示例：@Retention(RetentionPolicy.RUNTIME)

3.1.3 @Documented

@Documented用于表示自定义注解可以被javadoc之类的工具文档化，没有成员。

使用示例：@Documented

3.1.4 @Inherited

@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。

当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

使用示例：@Inherited

3.2 开始自定义注解

定义注解格式：

　　public @interface 注解名 {定义体}

注解参数的可支持数据类型：

1. 所有基本数据类型（int,float,boolean,byte,double,char,long,short)
2. String类型
3. Class类型
4. enum类型
5. Annotation类型
6. 以上所有类型的数组

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。

@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。

注意：

• 只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；　

• 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;　　

• 如果只有一个参数成员,最好把参数名称设为”value”,后加小括号.

3.3 例子

定义一个注解@Info

[java]  view plain  copy

1. package io.mykit.annotation.jdk.provider;  
2.   
3. import java.lang.annotation.Documented;  
4. import java.lang.annotation.ElementType;  
5. import java.lang.annotation.Retention;  
6. import java.lang.annotation.RetentionPolicy;  
7. import java.lang.annotation.Target;  
8.   
9. /** 
10.  * 定义基本信息Info注解 
11.  * @author liuyazhuang 
12.  * 
13.  */  
14. @Target(ElementType.TYPE)  
15. @Retention(RetentionPolicy.RUNTIME)  
16. @Documented  
17. public @interface Info {  
18.     String name() default "liuyazhuang";  
19.     int age() default 18;  
20.     String[] hobby() default {"basketball", "football"};  
21. }  

再定义一个注解@Gender

[java]  view plain  copy

1. package io.mykit.annotation.jdk.provider;  
2.   
3. import java.lang.annotation.Documented;  
4. import java.lang.annotation.ElementType;  
5. import java.lang.annotation.Retention;  
6. import java.lang.annotation.RetentionPolicy;  
7. import java.lang.annotation.Target;  
8.   
9. /** 
10.  * 定义性别注解 
11.  * @author liuyazhuang 
12.  * 
13.  */  
14. @Target(ElementType.FIELD)  
15. @Retention(RetentionPolicy.RUNTIME)  
16. @Documented  
17. public @interface Gender {  
18.       
19.     public enum GenderEnum{BOY, GIRL}  
20.       
21.     GenderEnum gender() default GenderEnum.BOY;  
22. }  

定义一个User类，使用刚才定义的两个注解:

[java]  view plain  copy

1. package io.mykit.annotation.jdk.provider.entity;  
2.   
3. import io.mykit.annotation.jdk.provider.Gender;  
4. import io.mykit.annotation.jdk.provider.Info;  
5. import io.mykit.annotation.jdk.provider.Gender.GenderEnum;  
6.   
7. /** 
8.  * 以注解标识的类 
9.  * @author liuyazhuang 
10.  * 
11.  */  
12. @Info(name="liuyazhuang", age = 18, hobby = {"Java", "C", "Python", "Go"})  
13. public class User {  
14.       
15.     @Gender(gender = GenderEnum.BOY)  
16.     private String sex;  
17.   
18.     public String getSex() {  
19.         return sex;  
20.     }  
21.   
22.     public void setSex(String sex) {  
23.         this.sex = sex;  
24.     }  
25.       
26. }  

定义一个注解处理器AnnotationProcess，用于处理注解内容：

[java]  view plain  copy

1. package io.mykit.annotation.jdk.provider.parser;  
2.   
3. import java.lang.reflect.Field;  
4.   
5. import io.mykit.annotation.jdk.provider.Gender;  
6. import io.mykit.annotation.jdk.provider.Info;  
7.   
8. /** 
9.  * 解析Info注解和Gender注解 
10.  * @author liuyazhuang 
11.  * 
12.  */  
13. public class AnnotationProcessor {  
14.     /** 
15.      * 解析clazz实例中的指定注解 
16.      * @param clazz：要传入的clazz对象 
17.      */  
18.     public static void parseAnnotation(Class<?> clazz){  
19.         //clazz是以Info注解修饰  
20.         if(clazz.isAnnotationPresent(Info.class)){  
21.             //获取Info注解  
22.             Info annotation = clazz.getAnnotation(Info.class);  
23.             System.out.println(annotation);  
24.             System.out.println(annotation.name());  
25.             System.out.println(annotation.age());  
26.             String[] bobby = annotation.hobby();  
27.             for(String str : bobby){  
28.                 System.out.println(str);  
29.             }  
30.         }  
31.         Field[] fields = clazz.getDeclaredFields();  
32.         if(fields != null && fields.length > 0){  
33.             for(Field field : fields){  
34.                 if(field.isAnnotationPresent(Gender.class)){  
35.                     Gender annotation = field.getAnnotation(Gender.class);  
36.                     System.out.println(annotation);  
37.                     System.out.println(annotation.gender());  
38.                 }  
39.             }  
40.         }  
41.     }  
42. }  

最后，定义测试类：

[java]  view plain  copy

1. package io.mykit.annotation.jdk.provider;  
2.   
3. import org.junit.Test;  
4.   
5. import io.mykit.annotation.jdk.provider.entity.User;  
6. import io.mykit.annotation.jdk.provider.parser.AnnotationProcessor;  
7.   
8. /** 
9.  * 测试自定义注解 
10.  * @author liuyazhuang 
11.  * 
12.  */  
13. public class AnnotationTest {  
14.       
15.     @Test  
16.     public void testAnnotation(){  
17.         AnnotationProcessor.parseAnnotation(User.class);  
18.     }  
19. }  

测试结果如下：

[plain]  view plain  copy

1. @io.mykit.annotation.jdk.provider.Info(name=liuyazhuang, age=18, hobby=[Java, C, Python, Go])  
2. liuyazhuang  
3. 18  
4. Java  
5. C  
6. Python  
7. Go  
8. @io.mykit.annotation.jdk.provider.Gender(gender=BOY)  
9. BOY