2. 程式人生 > >java 註解

java 註解

阿新 • • 發佈：2018-02-01
element 允許 inter 枚舉類型 print 編譯器 反射api 並不是 err

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 級別註解有效

（這段建議看完全文後在來回顧）。 多說無益，下面就一步步從零開始建一個我們自己的註解。

建第一個註解

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

在下面這個程序中使用它

[java] view plain copy
  1. package com.tmser.annotation;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. /**
  7. * 這個類專門用來測試註解使用
  8. * @author tmser
  9. */
  10. @TestA //使用了類註解
  11. public class UserAnnotation {
  13. @TestA //使用了類成員註解
  14. private Integer age;
  16. @TestA //使用了構造方法註解
  17. public UserAnnotation(){
  19. }
  21. @TestA //使用了類方法註解
  22. public void a(){
  23. @TestA //使用了局部變量註解
  24. Map m = new HashMap(0);
  25. }
  27. public void b(@TestA Integer a){ //使用了方法參數註解
  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，動手在前面我們編寫的註解上加上元註解。

[java] view plain copy
  1. package com.tmser.annotation;
  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 {
  12. }

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

[java] view plain copy
  1. @TestA package com.tmser.annotation;

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

Package annotations must be in file package-info.java ，e 文雖然不好，但這個簡單的還是難不倒幾個人的，package 註解必須定義在 package-info.java 中。package-info 又是什麽東西，你百度好了。到此 target 元註解就全部完成了。

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

[java] view plain copy
  1. package com.tmser.annotation;
  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. @Retention(RetentionPolicy.RUNTIME)
  12. public @interface TestA {
  13. }

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

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

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

代碼：

[java] view plain copy
  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. }

下面改下我們的測試類：

[java] view plain copy
  1. package com.tmser.annotation;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. /**
  7. * 這個類專門用來測試註解使用
  8. * @author tmser
  9. */
  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. } 



 


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


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


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


 



[java] view plain copy
 



    

  1. public interface AnnotatedElement {  
    2. 

  2.         boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);  
    3. 

  3.         <T extends Annotation> T getAnnotation(Class<T> annotationClass);  
    4. 

  4.         Annotation[] getAnnotations();  
    5. 

  5.         Annotation[] getDeclaredAnnotations();  
    6. 

  6. }  
    7. 



 


    

  • isAnnotationPresent：判斷是否標註了指定註解
    • 

  • getAnnotation：獲取指定註解，沒有則返回null
    • 

  • getAnnotations：獲取所有註解，包括繼承自基類的，沒有則返回長度為0的數組
    • 

  • getDeclaredAnnotations：獲取自身顯式標明的所有註解，沒有則返回長度為0的數組
    • 



 



[java] view plain copy
 



    

  1. package com.tmser.annotation;  
    2. 

  2. import java.lang.annotation.Annotation;  
    3. 

  3. import java.lang.reflect.Constructor;  
    4. 

  4. import java.lang.reflect.Method;  
    5. 

  5. public class ParseAnnotation {  
    6. 

  6.     /** 
    7. 

  7.      * 簡單打印出UserAnnotation 類中所使用到的類註解 
    8. 

  8.      * 該方法只打印了 Type 類型的註解 
    9. 

  9.      * @throws ClassNotFoundException 
    10. 

  10.      */  
    11. 

  11.     public static void parseTypeAnnotation() throws ClassNotFoundException {    
    12. 

  12.         Class clazz = Class.forName("com.tmser.annotation.UserAnnotation");   
    13. 

  13.           
    14. 

  14.         Annotation[] annotations = clazz.getAnnotations();    
    15. 

  15.         for (Annotation annotation : annotations) {    
    16. 

  16.             TestA testA = (TestA)annotation;  
    17. 

  17.             System.out.println("id= \""+testA.id()+"\"; name= \""+testA.name()+"\"; gid = "+testA.gid());    
    18. 

  18.         }    
    19. 

  19.     }   
    20. 

  20.     /** 
    21. 

  21.      * 簡單打印出UserAnnotation 類中所使用到的方法註解 
    22. 

  22.      * 該方法只打印了 Method 類型的註解 
    23. 

  23.      * @throws ClassNotFoundException 
    24. 

  24.      */  
    25. 

  25.     public static void parseMethodAnnotation(){  
    26. 

  26.         Method[] methods = UserAnnotation.class.getDeclaredMethods();    
    27. 

  27.         for (Method method : methods) {    
    28. 

  28.             /*  
    29. 

  29.              * 判斷方法中是否有指定註解類型的註解  
    30. 

  30.              */    
    31. 

  31.             boolean hasAnnotation = method.isAnnotationPresent(TestA.class);    
    32. 

  32.             if (hasAnnotation) {    
    33. 

  33.                 /*  
    34. 

  34.                  * 根據註解類型返回方法的指定類型註解  
    35. 

  35.                  */    
    36. 

  36.                 TestA annotation = method.getAnnotation(TestA.class);    
    37. 

  37.                 System.out.println("method = " + method.getName()    
    38. 

  38.                         + " ; id = " + annotation.id() + " ; description = "    
    39. 

  39.                         + annotation.name() + "; gid= "+annotation.gid());    
    40. 

  40.             }    
    41. 

  41.         }    
    42. 

  42.     }  
    43. 

  43.     /** 
    44. 

  44.      * 簡單打印出UserAnnotation 類中所使用到的方法註解 
    45. 

  45.      * 該方法只打印了 Method 類型的註解 
    46. 

  46.      * @throws ClassNotFoundException 
    47. 

  47.      */  
    48. 

  48.     public static void parseConstructAnnotation(){  
    49. 

  49.         Constructor[] constructors = UserAnnotation.class.getConstructors();    
    50. 

  50.         for (Constructor constructor : constructors) {   
    51. 

  51.             /*  
    52. 

  52.              * 判斷構造方法中是否有指定註解類型的註解  
    53. 

  53.              */    
    54. 

  54.             boolean hasAnnotation = constructor.isAnnotationPresent(TestA.class);    
    55. 

  55.             if (hasAnnotation) {    
    56. 

  56.                 /*  
    57. 

  57.                  * 根據註解類型返回方法的指定類型註解  
    58. 

  58.                  */    
    59. 

  59.                 TestA annotation =(TestA) constructor.getAnnotation(TestA.class);    
    60. 

  60.                 System.out.println("constructor = " + constructor.getName()    
    61. 

  61.                         + " ; id = " + annotation.id() + " ; description = "    
    62. 

  62.                         + annotation.name() + "; gid= "+annotation.gid());    
    63. 

  63.             }    
    64. 

  64.         }    
    65. 

  65.     }  
    66. 

  66.       
    67. 

  67.     public static void main(String[] args) throws ClassNotFoundException {  
    68. 

  68.         parseTypeAnnotation();  
    69. 

  69.         parseMethodAnnotation();  
    70. 

  70.         parseConstructAnnotation();  
    71. 

  71.     }  
    72. 

  72. }  
    73. 



 


 


先別說話，運行：


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


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


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


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


   最後提醒下：


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


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


 疑問：


      即 ElementType. ANNOTATION_TYPE：註解類型，到底什麽作用，我發現即使不使用這個類型，我們自定義的註解也可以用來註釋其他註解（eclipse 報錯，但仍可以編譯，也仍可以在測試類中讀取出報錯的註解，使用TYPE編譯器都不報錯），難道只是標示註解是個元註解，知道的麻煩告知一下。
java 註解
   
 
 
 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
Java註解配置數據庫表主鍵

     
 java   gen   http   運行   數據庫表   integer   rac   bsp   ber    
一
數字類型 Integer

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)

 

 運行後就Hiber 



  
 

    


    
    
java註解學習筆記

     
 ati   type類   包括   generated   override   stack   color   類繼承   boolean   

今天看了下有關java註解的視頻學習資料在。做點筆記：
學java註解的目的：
能看別人代碼，特別是框架代碼。由於肯定與註解有關。
編程更簡潔，代碼清晰。

 



  
 

    


    
    
JAVA註解Annotation

     
 深入理解java   java註解   annotation   註解處理器   annotatedelement   從 JDK 5.0 開始, Java 增加了對元數據(MetaData) 的支持, 也就是 Annotation(註解)Annotation 其實就是代碼裏的特殊標記, 這些標記可以在編譯, 



  
 

    


    
    
Java註解

     
 override   variable   ted   控制   get   face   ack   autowired   err   一、註解的分類：
1、按照運行機制分：
1）、源碼註解：只在源碼中存在，.java文件中
2）、編譯時註解：在源碼和.class文件中都存在 如：@Override @D 



  
 

    


    
    
Java註解學習

     
 int   marker   double   fault   efault   public   ngs   spa   default   Java提供了特定的註解(比較基礎的例如：Override、Deprecated、SuppressWarnings)。
自定義註解：
有三種：
普通註解：

publ 



  
 

    


    
    
java註解框架

     
 andro   override   但是   tar   會有   定義   註解處理器   mes   port   姓名：鄧勇  班級：軟件151
 1.元註解2.自定義註解3.註解處理器android註解框架解析我們經常會在java代碼裏面看到：[email protected]/*  */ 



  
 

    


    
    
Java註解及反射得到註解

     
 -a   hide   for   dcb   his   port   ges   cnblogs   類名   





Class類的方法




f
 
 
 


package com.part1;
/**
 * 
 * @author pc
 *
 */
public class Studen 



  
 

    


    
    
Java--註解

     
 sel   select   get   賦值   cat   自動   ron   style   .com   一.註解的基本
1.註解的通俗理解
       註解（Annotation） 為我們在代碼中添加信息提供了一種形式化的方法，是我們可以在稍後 某個時刻方便地使用這些數據（通過解析註解來使用這些 



  
 

    


    
    
java註解和反射的結合使用

     
 分享   spa   tac   over   ace   註解   []   sys   string   首先反射註解，那麽保留策略必須是Runtime，[email protected]/*  */(RetentionPolicy.RUNTIME)
①定義一個註解類

@Retention(R 



  
 

    


    
    
Java註解(1)-註解基礎

     
 3.4   bsp   編譯器   rri   一個   基本   meta   格式   adding   註解（Annotation）是在JAVA5中開始引入的，它為在代碼中添加信息提供了一種新的方式。註解在一定程度上把元數據與源代碼文件結合在一起，正如許多成熟的框架（Spring）所做的那樣。那麽，註解 



  
 

    


    
    
[轉帖收集] Java註解

     
 cto   這一   字段   declare   rri   鼓勵   指定   包含成員   容易   1、Annotation
       它的作用是修飾編程元素。什麽是編程元素呢？例如：包、類、構造方法、方法、成員變量等。Annotation（註解）就是Java提供了一種元程序中的元素關聯任何信息 



  
 

    


    
    
java註解細節

     
 ann   反射機制   cor   father   resource   類的方法   內部   spring   uri   　　現在很多框架都使用註解了，典型的像Spring裏面就可以看到大量的註解，比如@Service,@Controller這一類的都是註解。註解Annotation是java一項很 



  
 

    


    
    
java註解的基本知識

     
 生命周期   原理   span   java內置   rri   gpo   中一   eth   註解   1： 註解：Annotation是一種應用於類、方法、參數、變量、構造器及包生命中的特殊修飾符，是一種由JSR-175標準選擇用來描述代碼的元數據。
Java中如下的4種註解，專門負責新註解的創建： 



  
 

    


    
    
java 註解

     
 element   允許   inter   枚舉類型   print   編譯器   反射api   並不是   err   java 註解，從名字上看是註釋，解釋。但功能卻不僅僅是註釋那麽簡單。註解（Annotation） 為我們在代碼中添加信息提供了一種形式化的方法，是我們可以在稍後某個時刻方便地使用這 



  
 

    


    
    
Java - 註解(1)

     
 接口   rtp   font   parse   def   color   style   face   ()   大綱：使用註解的好處；註解的概念；Java中的常見註解；註解的分類；自定義註解；
註解的好處：讓編程更加簡潔，代碼更加清晰；
註解的概念：Java提供了一種原程序中的元素關聯任何信息和任何元 



  
 

    


    
    
Java註解之Retention、Documented、Target介紹

     
 javadoc   聲明   示例   class   文件   con   dash   tor   描述   先看代碼，後面一個個來解析：

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, Elemen 



  
 

    


    
    
【iMooc】全面解析java註解

     
 test   sql語句   字符   con   public   insert   OS   直接   變量   在慕課上學習了一個關於java註解的課程，下面是筆記以及一些源碼。
Annotation——註解
1.JDK中的註解
JDK中包括下面三種註解：
@Override：標記註解(marker a 



  
 

    


    
    
Java 註解（原理及其使用）

     
 def   ava   IT   使用範圍   自動化測試   決定   加載   del   特定   　　一、註解（annotation）介紹
　　Java在JDK5中引入源代碼的註解機制。
　　1、什麽是註解？
　　註解為代碼添加了元數據，元數據是關於數據的組織、數據域及其關系的說明信息。
　　更通俗的 



  
 

    


    
    
秒懂，Java 註解 （Annotation）你可以這樣學

     
 face   幹什麽   有一種   博客   作用   習慣   lis   如果   手機    這處圖片引自老羅的博客。為了避免不必要的麻煩，首先聲明我個人比較尊敬老羅的。至於為什麽放這張圖，自然是為本篇博文服務，接下來我自會說明。好了，可以開始今天的博文了。
Annotation 中文譯過來就是註解、 



  
 

    


    
    
Java註解Retention、Documented、Target的含義

     
 policy   所有   AD   parameter   重點   信息   ted   存在   通過   
 
Retention註解
Retention(保留)註解說明,這種類型的註解會被保留到那個階段. 有三個值: 1.RetentionPolicy.SOURCE —— 這種類型的Annotati