碼上歡樂
相關內容    簡體    繁體

java 注解的幾大作用及使用方法詳解

本文轉載自   查看原文   2017-02-07 16:00   23544 

Java 注解，從名字上看是注釋，解釋。但功能卻不僅僅是注釋那么簡單。注解（Annotation） 為我們在代碼中添加信息提供了一種形式化的方法，是我們可以在稍后某個時刻方便地使用這些數據（通過 解析注解 來使用這些數據），常見的作用有以下幾種：

  • 生成文檔。這是最常見的，也是java 最早提供的注解。常用的有@see @param @return 等
  • 跟蹤代碼依賴性，實現替代配置文件功能。比較常見的是spring 2.5 開始的基於注解配置。作用就是減少配置。現在的框架基本都使用了這種配置來減少配置文件的數量。也是
  • 在編譯時進行格式檢查。如@Override 放在方法前，如果你這個方法並不是覆蓋了超類方法，則編譯時就能檢查出。

包 java.lang.annotation 中包含所有定義自定義注解所需用到的原注解和接口。如接口 java.lang.annotation.Annotation 是所有注解繼承的接口,並且是自動繼承，不需要定義時指定，類似於所有類都自動繼承Object。

該包同時定義了四個元注解，Documented,Inherited,Target(作用范圍，方法，屬性，構造方法等),Retention(生命范圍，源代碼，class,runtime)。下面將在實例中逐個講解他們的作用，及使用方法。

Inherited : 在您定義注解后並使用於程序代碼上時，預設上父類別中的注解並不會被繼承至子類別中，您可以在定義注解時加上java.lang.annotation.Inherited 限定的Annotation，這讓您定義的Annotation型別被繼承下來。注意注解繼承只針對class 級別注解有效（這段建議看完全文后在來回顧）。 多說無益，下面就一步步從零開始建一個我們自己的注解。

   建第一個注解

  1. package com.tmser.annotation;
  2. /**
  3. *
  4. *@interface用來聲明一個注解，其中的每一個方法實際上是聲明了一個配置參數。
  5. *方法的名稱就是參數的名稱，返回值類型就是參數的類型。
  6. *可以通過default來聲明參數的默認值。
  7. *在這里可以看到@Retention和@Target這樣的元注解，用來聲明注解本身的行為。
  8. *@Retention用來聲明注解的保留策略，有CLASS、RUNTIME和SOURCE這三種，
  9. *分別表示注解保存在類文件、JVM運行時刻和源代碼中。
  10. *只有當聲明為RUNTIME的時候，才能夠在運行時刻通過反射API來獲取到注解的信息。
  11. *@Target用來聲明注解可以被添加在哪些類型的元素上，如類型、方法和域等。
  12.  *就可以定義一個注解了，它將自動繼承Annotation
  13. */
  14. public @interface TestA {
  15. //這里定義了一個空的注解，它能干什么呢。我也不知道，但他能用。
  16. }


 

在下面這個程序中使用它：

  1. package com.tmser.annotation;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. /**
  7.  * 這個類專門用來測試注解使用
  8.  * @author tmser
  9.  */
  10. @TestA    //使用了類注解
  11. public class UserAnnotation {
  12.     
  13.     @TestA //使用了類成員注解
  14.     private Integer age;
  15.     
  16.     @TestA //使用了構造方法注解
  17.     public UserAnnotation(){
  18.         
  19.     }
  20.     @TestA //使用了類方法注解
  21.     public void a(){
  22.         @TestA //使用了局部變量注解
  23.         Map m = new HashMap(0);
  24.     }
  25.     
  26.     public void b(@TestA Integer a){ //使用了方法參數注解
  27.         
  28.     }
  29. }

編譯沒有報錯，ok，一個注解實驗完成。這個注解也太簡單了吧，好像什么信息也不能傳遞。別急下面就來一步步完善它，也該四位元注解依次開始上場了。

 

四個元注解分別是：@Target,@Retention,@Documented,@Inherited ，再次強調下元注解是Java API提供，是專門用來定義注解的注解，其作用分別如下。
   
        @Target 表示該注解用於什么地方，可能的值在枚舉類 ElemenetType 中，包括： 
          ElemenetType.CONSTRUCTOR 構造器聲明 
          ElemenetType.FIELD 域聲明（包括 enum 實例） 

          ElemenetType.LOCAL_VARIABLE 局部變量聲明

          ElemenetType.ANNOTATION_TYPE 作用於注解量聲明

          ElemenetType.METHOD 方法聲明

          ElemenetType.PACKAGE 包聲明 
          ElemenetType.PARAMETER 參數聲明 
          ElemenetType.TYPE 類，接口（包括注解類型）或enum聲明 
           
     @Retention 表示在什么級別保存該注解信息。可選的參數值在枚舉類型 RetentionPolicy 中，包括： 
          RetentionPolicy.SOURCE 注解將被編譯器丟棄 
          RetentionPolicy.CLASS 注解在class文件中可用，但會被VM丟棄 
          RetentionPolicy.RUNTIME VM將在運行期也保留注釋，因此可以通過反射機制讀取注解的信息。 
           
      @Documented 將此注解包含在 javadoc 中 ，它代表着此注解會被javadoc工具提取成文檔。在doc文檔中的內容會因為此注解的信息內容不同而不同。相當與@see,@param 等。
       
      @Inherited 允許子類繼承父類中的注解，例子中補充。

   

學習最忌好高騖遠，我們就一個一個來實驗。

第一個：@Target，動手在前面我們編寫的注解上加上元注解。

 

  1. package com.tmser.annotation;
  2.  
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Target;
  5. /*
  6. * 定義注解 Test
  7. * 首先使用ElementType.TYPE
  8. */
  9. @Target(ElementType.PACKAGE)
  10. public @interface TestA {
  11.  
  12. }

ctrl+ s 保存，今天電腦比較給力，我們的測試類那邊立馬出現了一堆錯誤，除了類注解。我想到這，聰明的你立刻明白了這個元注解的意義了。是不是想當然的偷起懶來了。？難道還有意外？細心的朋友應該發現了，我們的測試類少了一個屬性沒用，就是ElemenetType.PACKAGE。在我們的注解加上這個屬性的元注解后，我們測試程序的元注解全部陣亡，不對，還有一個沒加呢，好加上。package 包，想當然是加載 package 前面。即

  1. @TestA package com.tmser.annotation;

 

什么也報錯。這就搞不明白了，不加在這加哪去呢。我也不知道了，不過這是編譯錯誤，我們的eclipse 將錯誤給我們指出了，就是

  Package annotations must be in file package-info.java ，e 文雖然不好，但這個簡單的還是難不倒幾個人的，package 注解必須定義在 package-info.java 中。package-info 又是什么東西，好了為節省你們的時間幫你百度好了，傳送門。ok,到此 target 元注解就全部完成了。

 

第二個元注解： @Retention 參數 RetentionPolicy。有了前面的經驗這個注解理解起來就簡單多了，並且幸運的是這個注解還沒有特殊的屬性值。 簡單演示下如何使用：

 

  1. package com.tmser.annotation;
  2.  
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Target;
  5. /*
  6. * 定義注解 Test
  7. * 首先使用ElementType.TYPE
  8. * 運行級別定為 運行時，以便后面測試解析
  9.  */
  10. @Target(ElementType.PACKAGE)

  11.  

  12. @Retention(RetentionPolicy.RUNTIME)

  13.  
  14. public @interface TestA {
  15.  
  16. }

第三和第四個元注解就不再舉例了。比較簡單，也沒有值，相信看過上面的解釋也就清楚了。下面我們還是繼續來深入的探討下注解的使用。上面的例子都非常簡單，注解連屬性都沒有。ok，下面我們就來定義一個有屬性的注解，並在例子程序中獲取都注解中定義的值。

開始之前將下定義屬性的規則：

        @interface用來聲明一個注解，其中的每一個方法實際上是聲明了一個配置參數。方法的名稱就是參數的名稱，返回值類型就是參數的類型（返回值類型只能是基本類型、Class、String、enum）。可以通過default來聲明參數的默認值。

代碼：

 

  1. /*
  2. * 定義注解 Test
  3. * 為方便測試：注解目標為類 方法，屬性及構造方法
  4. * 注解中含有三個元素 id ,name和 gid;
  5. * id 元素 有默認值 0
  6. */
  7. @Target({TYPE,METHOD,FIELD,CONSTRUCTOR})
  8. @Retention(RetentionPolicy.RUNTIME)
  9. public @interface TestA {
  10. String name();
  11. int id() default 0;
  12. Class<Long> gid();
  13. }

 

 

 

下面改下我們的測試類：

 

  1. package com.tmser.annotation;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. /**
  7. * 這個類專門用來測試注解使用
  8. * @author tmser
  9. */
  10.  
  11. @TestA(name="type",gid=Long.class) //類成員注解
  12. public class UserAnnotation {
  14. @TestA(name="param",id=1,gid=Long.class) //類成員注解
  15. private Integer age;
  17. @TestA (name="construct",id=2,gid=Long.class)//構造方法注解
  18. public UserAnnotation(){
  20. }
  21. @TestA(name="public method",id=3,gid=Long.class) //類方法注解
  22. public void a(){
  23. Map<String,String> m = new HashMap<String,String>(0);
  24. }
  26. @TestA(name="protected method",id=4,gid=Long.class) //類方法注解
  27. protected void b(){
  28. Map<String,String> m = new HashMap<String,String>(0);
  29. }
  31. @TestA(name="private method",id=5,gid=Long.class) //類方法注解
  32. private void c(){
  33. Map<String,String> m = new HashMap<String,String>(0);
  34. }
  36. public void b(Integer a){
  38. }
  39. }
  40.  

 

下面到了最重要的一步了，就是如何讀取我們在類中定義的注解。只要讀取出來了使用的話就簡單了。

jdk1.5 既然增加了注解，肯定就增加了相關讀取的api

在java.lang.reflect包中新增了AnnotatedElement接口，JDK源碼如下：

 

  1. public interface AnnotatedElement {
  2. boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
  3. <T extends Annotation> T getAnnotation(Class<T> annotationClass);
  4. Annotation[] getAnnotations();
  5. Annotation[] getDeclaredAnnotations();
  6. }

 

 

  • isAnnotationPresent：判斷是否標注了指定注解
  • getAnnotation：獲取指定注解，沒有則返回null
  • getAnnotations：獲取所有注解，包括繼承自基類的，沒有則返回長度為0的數組
  • getDeclaredAnnotations：獲取自身顯式標明的所有注解，沒有則返回長度為0的數組

 

  1. package com.tmser.annotation;
  2.  
  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Constructor;
  5. import java.lang.reflect.Method;
  6.  
  7. public class ParseAnnotation {
  8.  
  9. /**
  10. * 簡單打印出UserAnnotation 類中所使用到的類注解
  11. * 該方法只打印了 Type 類型的注解
  12. * @throws ClassNotFoundException
  13. */
  14. public static void parseTypeAnnotation() throws ClassNotFoundException {
  15. Class clazz = Class.forName("com.tmser.annotation.UserAnnotation");
  17. Annotation[] annotations = clazz.getAnnotations();
  18. for (Annotation annotation : annotations) {
  19. TestA testA = (TestA)annotation;
  20. System.out.println("id= \""+testA.id()+"\"; name= \""+testA.name()+"\"; gid = "+testA.gid());
  21. }
  22. }
  24. /**
  25. * 簡單打印出UserAnnotation 類中所使用到的方法注解
  26. * 該方法只打印了 Method 類型的注解
  27. * @throws ClassNotFoundException
  28. */
  29. public static void parseMethodAnnotation(){
  30. Method[] methods = UserAnnotation.class.getDeclaredMethods();
  31. for (Method method : methods) {
  32. /*
  33. * 判斷方法中是否有指定注解類型的注解
  34. */
  35. boolean hasAnnotation = method.isAnnotationPresent(TestA.class);
  36. if (hasAnnotation) {
  37. /*
  38. * 根據注解類型返回方法的指定類型注解
  39. */
  40. TestA annotation = method.getAnnotation(TestA.class);
  41. System.out.println("method = " + method.getName()
  42. + " ; id = " + annotation.id() + " ; description = "
  43. + annotation.name() + "; gid= "+annotation.gid());
  44. }
  45. }
  46. }
  48. /**
  49. * 簡單打印出UserAnnotation 類中所使用到的方法注解
  50. * 該方法只打印了 Method 類型的注解
  51. * @throws ClassNotFoundException
  52. */
  53. public static void parseConstructAnnotation(){
  54. Constructor[] constructors = UserAnnotation.class.getConstructors();
  55. for (Constructor constructor : constructors) {
  56. /*
  57. * 判斷構造方法中是否有指定注解類型的注解
  58. */
  59. boolean hasAnnotation = constructor.isAnnotationPresent(TestA.class);
  60. if (hasAnnotation) {
  61. /*
  62. * 根據注解類型返回方法的指定類型注解
  63. */
  64. TestA annotation =(TestA) constructor.getAnnotation(TestA.class);
  65. System.out.println("constructor = " + constructor.getName()
  66. + " ; id = " + annotation.id() + " ; description = "
  67. + annotation.name() + "; gid= "+annotation.gid());
  68. }
  69. }
  70. }
  72. public static void main(String[] args) throws ClassNotFoundException {
  73. parseTypeAnnotation();
  74. parseMethodAnnotation();
  75. parseConstructAnnotation();
  76. }
  77. }

 

先別說話，運行：

 

  1. id= "0"; name= "type"; gid = class java.lang.Long
  2. method = c ; id = 5 ; description = private method; gid= class java.lang.Long
  3. method = a ; id = 3 ; description = public method; gid= class java.lang.Long
  4. method = b ; id = 4 ; description = protected method; gid= class java.lang.Long
  5. constructor = com.tmser.annotation.UserAnnotation ; id = 2 ; description = construct; gid= class java.lang.Long

 

看到了吧，我們定義的注解都完整的輸出了，你要使用哪個，直接拿去用就好了。

為了不讓這篇文章打開太慢，我省略了類屬性注解，及參數注解的解析。其實都大同小異。

另外，我也沒有舉使用例子。因為我認為好的教程是講的詳細的同時，還會留有擴展。如果我全部寫出來，而你只是學習的話，那基本不會自己去動腦了，而是復制粘貼運行一遍完事。

   最后提醒下：

     1. 要用好注解，必須熟悉java 的反射機制，從上面的例子可以看出，注解的解析完全依賴於反射。

     2. 不要濫用注解。平常我們編程過程很少接觸和使用注解，只有做設計，且不想讓設計有過多的配置時。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 JAVA 注解的幾大作用及使用方法詳解 telnet作用和 命令使用方法詳解 @Results注解使用方法 java中責任鏈模式詳解和使用方法 基於注解的聲明式事務的使用方法 SpringMVC的@Validated校驗注解使用方法 SSM框架原理,作用及使用方法 Java Web(五) JSP詳解(四大作用域九大內置對象等) postman的使用方法詳解 EVO使用方法詳解
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM