深入浅出Java Annotation(元注解和自定义注解）

标签：

一、基本概述

　　 Annontation是Java5开始引入的新特征。中文名称一般叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。

　　更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或框架使用的。

    Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

二、原理

　　Annotation其实是一种接口。通过Java的反射机制相关的API来访问Annotation信息。相关类（框架或工具中的类即使用注解的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。

　　Annoation和程序代码的隔离性：Annotation是不会影响程序代码的执行，无论Annotation怎么变化，代码都始终如一地执行。

　　忽略性：Java语言解释器在工作时会忽略这些annotation，因此在JVM 中这些Annotation是“不起作用”的，只能通过配套的工具才能对这些Annontaion类型的信息进行访问和处理。

　　Annotation与interface的异同：

　　1）、Annotation类型使用关键字@interface而不是interface。

　　这个关键字声明隐含了一个信息：它是继承了java.lang.annotation.Annotation接口，并非声明了一个interface。

　　2）、Annotation类型、方法定义是独特的、受限制的。

　　Annotation 类型的方法必须声明为无参数、无异常抛出的。

     这些方法定义了Annotation的成员：方法名成为了成员名，而方法返回值成为了成员的类型。方法返回值类型必须为primitive类型、Class类型、枚举类型、annotation类型或者由前面类型之一作为元素的一维数组。方法的后面可以使用 default和一个默认数值来声明成员的默认值，null不能作为成员默认值，这与我们在非Annotation类型中定义方法有很大不同。

　　Annotation类型和它的方法不能使用Annotation类型的参数、成员不能是generic。只有返回值类型是Class的方法可以在Annotation类型中使用generic，因为此方法能够用类转换将各种类型转换为Class。

　　3）、Annotation类型又与接口有着近似之处。

　　它们可以定义常量、静态成员类型（比如枚举类型定义）。Annotation类型也可以如接口一般被实现或者继承。

三、应用场合

　　Annotation一般作为一种辅助途径，应用在软件框架或工具中，在这些工具类中根据不同的 Annontation注解信息采取不同的处理过程或改变相应程序元素（类、方法及成员变量等）的行为。

　　例如：Junit、Struts、Spring等流行工具框架中均广泛使用了Annontion。使代码的灵活性大提高。

四、元注解

      元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：

　　1.@Target ,
　　2.@Retention,
　　3.@Documented,
　　4.@Inherited
　　这些类型和它们所支持的类在java.lang.annotation包中可以找到。下面我们看一下每个元注解的作用和相应分参数的使用说明。

　@Target：

　　　@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

　　作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

　　取值(ElementType)有：

　　　　1.CONSTRUCTOR:用于描述构造器
　　　　2.FIELD:用于描述域即类成员变量
　　　　3.LOCAL_VARIABLE:用于描述局部变量
　　　　4.METHOD:用于描述方法
　　　　5.PACKAGE:用于描述包
　　　　6.PARAMETER:用于描述参数
　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

实例：

Java代码  

1. <strong style="font-size: 16px;">@Target(ElementType.TYPE)  
2. public @interface Table {  
3.     /** 
4.      * 数据表名称注解，默认值为类名称 
5.      * @return 
6.      */  
7.     public String tableName() default "className";  
8. }  
9.   
10. @Target(ElementType.FIELD)  
11. public @interface NoDBColumn {  
12.   
13. }</strong>  

注解Table 可以用于注解类、接口(包括注解类型)或enum声明,而注解NoDBColumn仅可用于注解类的成员变量。

　@Retention：

  @Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

　　作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）

　　取值（RetentionPoicy）有：

　　　　1.SOURCE:在源文件中有效（即源文件保留）
　　　　2.CLASS:在class文件中有效（即class保留）
　　　　3.RUNTIME:在运行时有效（即运行时保留）

　　Retention meta-annotation类型有唯一的value作为成员，它的取值来自java.lang.annotation.RetentionPolicy的枚举类型值。具体实例如下：

Java代码  

1. @Target(ElementType.FIELD)  
2. @Retention(RetentionPolicy.RUNTIME)  
3. public @interface Column {  
4.     public String name() default "fieldName";  
5.     public String setFuncName() default "setField";  
6.     public String getFuncName() default "getField";   
7.     public boolean defaultDBValue() default false;  
8. }  

 Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理。

　@Documented:

　　@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。

Java代码  

1. @Target(ElementType.FIELD)  
2. @Retention(RetentionPolicy.RUNTIME)  
3. @Documented  
4. public @interface Column {  
5.     public String name() default "fieldName";  
6.     public String setFuncName() default "setField";  
7.     public String getFuncName() default "getField";   
8.     public boolean defaultDBValue() default false;  
9. }  

 @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类型被发现，或者到达类继承结构的顶层.

实例代码：

Java代码  

1. <span style="font-size: 16px;">/** 
2.  *  
3.  * @author wangsheng 
4.  * 
5.  */  
6. @Inherited  
7. public @interface Greeting {  
8.     public enum FontColor{ BULE,RED,GREEN};  
9.     String name();  
10.     FontColor fontColor() default FontColor.GREEN;  
11. }</span>  

五、常见标准的Annotation

从java5版本开始，自带了三种标准annontation类型,

　　　　（1）、Override

　　java.lang.Override 是一个marker annotation类型，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种annotation在一个没有覆盖父类方法的方法时，java编译器将以一个编译错误来警示。

　　这个annotaton常常在我们试图覆盖父类方法而确又写错了方法名时加一个保障性的校验过程。

　　　　（2）、Deprecated

　　Deprecated也是一种marker annotation。当一个类型或者类型成员使用@Deprecated修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的 “延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为 @Deprecated，但编译器仍然要报警。

　　注意：@Deprecated这个annotation类型和javadoc中的 @deprecated这个tag是有区别的：前者是java编译器识别的，而后者是被javadoc工具所识别用来生成文档（包含程序成员为什么已经过时、它应当如何被禁止或者替代的描述）。

　　　　（3）、SuppressWarnings

　　此注解能告诉Java编译器关闭对类、方法及成员变量的警告。

　　有时编译时会提出一些警告，对于这些警告有的隐藏着Bug，有的是无法避免的，对于某些不想看到的警告信息，可以通过这个注解来屏蔽。

　　SuppressWarning不是一个marker annotation。它有一个类型为String[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-Xlint选项有效的警告名也同样对@SuppressWarings有效，同时编译器忽略掉无法识别的警告名。

　　annotation语法允许在annotation名后跟括号，括号中是使用逗号分割的name=value对用于为annotation的成员赋值：

代码：

Java代码  

1. @SuppressWarnings(value={"unchecked","fallthrough"})  
2.   
3. public void lintTrap() { /* sloppy method body omitted */ }  

   在这个例子中SuppressWarnings annotation类型只定义了一个单一的成员，所以只有一个简单的value={...}作为name=value对。又由于成员值是一个数组，故使用大括号来声明数组值。

   注意：我们可以在下面的情况中缩写annotation：当annotation只有单一成员，并成员命名为"value="。这时可以省去"value="。比如将上面的SuppressWarnings annotation进行缩写：

代码：

Java代码  

1. @SuppressWarnings({"unchecked","fallthrough"})  

如果SuppressWarnings所声明的被禁止警告个数为一个时，可以省去大括号：

Java代码  

1. @SuppressWarnings("unchecked")  

六、自定义注解

     使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。

       定义注解格式：
　　public @interface 注解名 {定义体}

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

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

　　Annotation类型里面的参数该怎么设定: 
　　第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；　 　
　　第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;　　
　　第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

简单的自定义注解和使用注解实例：

Java代码  

1. package annotation;  
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 wangsheng 
12.  * 
13.  */  
14. @Target(ElementType.FIELD)  
15. @Retention(RetentionPolicy.RUNTIME)  
16. @Documented  
17. public @interface FruitName {  
18.     String value() default "";  
19. }  

Java代码  

1. package annotation;  
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 peida 
12.  * 
13.  */  
14. @Target(ElementType.FIELD)  
15. @Retention(RetentionPolicy.RUNTIME)  
16. @Documented  
17. public @interface FruitColor {  
18.     /** 
19.      * 颜色枚举 
20.      * @author wangsheng 
21.      * 
22.      */  
23.     public enum Color{ BULE,RED,GREEN};  
24.       
25.     /** 
26.      * 颜色属性 
27.      * @return 
28.      */  
29.     Color fruitColor() default Color.GREEN;  
30.   
31. }  

Java代码  

1. package annotation;  
2.   
3. import annotation.FruitColor.Color;  
4.   
5. public class Apple {  
6.       
7.     @FruitName("Apple")  
8.     private String appleName;  
9.       
10.     @FruitColor(fruitColor=Color.RED)  
11.     private String appleColor;  
12.       
13.       
14.       
15.       
16.     public void setAppleColor(String appleColor) {  
17.         this.appleColor = appleColor;  
18.     }  
19.     public String getAppleColor() {  
20.         return appleColor;  
21.     }  
22.       
23.       
24.     public void setAppleName(String appleName) {  
25.         this.appleName = appleName;  
26.     }  
27.     public String getAppleName() {  
28.         return appleName;  
29.     }  
30.       
31.     public void displayName(){  
32.         System.out.println("水果的名字是：苹果");  
33.     }  
34. }  

 注解元素的默认值：

    注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。因此, 使用空字符串或0作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或缺失的状态，因为每个注解的声明中，所有元素都存在，并且都具有相应的值，为了绕开这个约束，我们只能定义一些特殊的值，例如空字符串或者负数，一次表示某个元素不存在，在定义注解时，这已经成为一个习惯用法。例如：

Java代码  

1. <strong style="margin: 0px; padding: 0px;">package annotation;  
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 wangsheng 
12.  * 
13.  */  
14. @Target(ElementType.FIELD)  
15. @Retention(RetentionPolicy.RUNTIME)  
16. @Documented  
17. public @interface FruitProvider {  
18.     /** 
19.      * 供应商编号 
20.      * @return 
21.      */  
22.     public int id() default -1;  
23.       
24.     /** 
25.      * 供应商名称 
26.      * @return 
27.      */  
28.     public String name() default "";  
29.       
30.     /** 
31.      * 供应商地址 
32.      * @return 
33.      */  
34.     public String address() default "";  
35. }</strong>  

定义了注解，并在需要的时候给相关类，类属性加上注解信息，如果没有响应的注解信息处理流程，注解可以说是没有实用价值。如何让注解真真的发挥作用，主要就在于注解处理方法，下一步我们将学习注解信息的获取和处理！

看完上面的例子后，来看一个更加具体的例子，该例子共涉及4个类：

清单1:Author.java

Java代码  

1. /** 
2.  *  
3.  */  
4. package com.wsheng.aggregator.annotation;  
5.   
6. import java.lang.annotation.Documented;  
7. import java.lang.annotation.ElementType;  
8. import java.lang.annotation.Retention;  
9. import java.lang.annotation.RetentionPolicy;  
10. import java.lang.annotation.Target;  
11.   
12. /** 
13.  * 定义作者信息，name和group 
14.  *  
15.  * @author Josh Wang(Sheng) 
16.  *  
17.  * @email  josh_wang23@hotmail.com 
18.  *  
19.  */  
20. @Retention(RetentionPolicy.RUNTIME)  
21. @Target(ElementType.METHOD)  
22. @Documented  
23. public @interface Author {  
24.       
25.     String name(); // 因为没有定义public，所以默认的访问权限为包权限，在定义时没有指定默认值，则使用时必须指定默认值  
26.     String group();  
27.   
28. }  

清单2:Description.java

Java代码  

1. /** 
2.  *  
3.  */  
4. package com.wsheng.aggregator.annotation;  
5.   
6. import java.lang.annotation.Documented;  
7. import java.lang.annotation.ElementType;  
8. import java.lang.annotation.Retention;  
9. import java.lang.annotation.RetentionPolicy;  
10. import java.lang.annotation.Target;  
11.   
12. /** 
13.  * 定义描述信息value 
14.  *  
15.  * @author Josh Wang(Sheng) 
16.  *  
17.  * @email  josh_wang23@hotmail.com 
18.  *  
19.  */  
20. @Retention(RetentionPolicy.RUNTIME)  
21. @Target(ElementType.TYPE)  
22. @Documented  
23. public @interface Description {  
24.   
25.     String value();// 只有一个属性时，最好定义为value，因为可以省略哦:)  
26. }  

清单3:Utility.java ： 使用自定义Annotation注解的类

Java代码  

1. /** 
2.  *  
3.  */  
4. package com.wsheng.aggregator.annotation;  
5.   
6. /** 
7.  * @author Josh Wang(Sheng) 
8.  *  
9.  * @email  josh_wang23@hotmail.com 
10.  *  
11.  */  
12. @Description(value="这是一个有用的工具类") // value可以省略  
13. public class Utility {  
14.   
15.     @Author(name="wangsheng", group="developer team")  
16.     public String work() {  
17.         return "work over!";  
18.     }  
19. }  

清单4:AnalysisAnnotation.java

Java代码  

1. /** 
2.  *  
3.  */  
4. package com.wsheng.aggregator.annotation;  
5.   
6. import java.lang.reflect.Method;  
7.   
8. /** 
9.  *  
10.  *在运行时分析处理annotation类型的信息 
11.  *  
12.  * @author Josh Wang(Sheng) 
13.  *  
14.  * @email  josh_wang23@hotmail.com 
15.  *  
16.  */  
17. public class AnalysisAnnotation {  
18.       
19.     public static void main(String[] args) {  
20.         try {  
21.               
22.             // 通过运行时反射API获得annotation信息  
23.             Class<?> rtClass = Class.forName("com.wsheng.aggregator.annotation.Utility");  
24.             Method[] methods = rtClass.getMethods();  
25.               
26.             boolean descriptionExist = rtClass.isAnnotationPresent(Description.class);  
27.             if (descriptionExist) {  
28.                 Description description = (Description)rtClass.getAnnotation(Description.class);  
29.                 System.out.println("Utility‘s Description --- > " + description.value());  
30.                   
31.                 for (Method method : methods) {  
32.                     if (method.isAnnotationPresent(Author.class)) {  
33.                         Author author = (Author)method.getAnnotation(Author.class);  
34.                         System.out.println("Utility‘s Author ---> " + author.name() + " from " + author.group());  
35.                     }  
36.                 }  
37.             }  
38.               
39.         } catch (ClassNotFoundException e) {  
40.             e.printStackTrace();  
41.         }  
42.     }  
43.   
44. }  

运行结果：

Utility‘s Description --- > 这是一个有用的工具类

Utility‘s Author ---> wangsheng from developer team

深入浅出Java Annotation(元注解和自定义注解）

标签：

原文地址：http://my.oschina.net/u/2273085/blog/477741