2. 程式人生 > >java 註解詳解+示例

java 註解詳解+示例

阿新 • • 發佈：2019-02-19

註解介紹

  • 1.5開始引入
  • 註解可以理解為一種描述資料的資料，或者可以稱為一種描述元資料的方法。
  • java提供的預設註解：@Override，@Deprecated。
  • 註解僅僅是元資料，和業務邏輯無關
  • 定義方法在 java.lang.annotation包中

元註解

java提供4中元註解來定義我們的註解
1. @Target,
2. @Retention,
3. @Documented,
4. @Inherited

1. @Target,

@Target說明了Annotation所修飾的物件範圍，即用於描述註解的使用範圍
1. CONSTRUCTOR:用於描述構造器
2. FIELD:用於描述域
3. LOCAL_VARIABLE:用於描述區域性變數
4. METHOD:用於描述方法
5. PACKAGE:用於描述包
6. PARAMETER:用於描述引數
7. TYPE:用於描述類、介面(包括註解型別) 或enum宣告
8. ANNOTATION_TYPE：適用於annotation型別,宣告註解型別
9. TYPE_PARAMETER:1.8版本
10. TYPE_USE： 1.8版本

TYPE_PARAMETER和TYPE_USE擴充套件了泛型使用場景，包括泛型、超類和介面實現、甚至是方法的Exception宣告。

2. @Retention

  1. SOURCE:在原始檔中有效（即原始檔保留），在編譯階段丟棄。註解在編譯結束之後就不再有任何意義，所以它們不會寫入位元組碼。比如：@Override
    2.CLASS:在class檔案中有效（即class保留）。在類載入的時候丟棄。在位元組碼檔案的處理中有用。註解預設使用這種方式。
    3.RUNTIME:在執行時有效（即執行時保留）。 始終不會丟棄，執行期也保留該註解，因此可以使用反射機制讀取該註解的資訊比。如：@Deprecated。比如Srping中的@Autowired，@ResponseBody等都屬於這一類。

表示需要在什麼級別儲存該註釋資訊，用於描述註解的生命週期

3. @Inherited

介紹：
元註解是一個標記註解，@Inherited闡述了某個被標註的型別是被繼承的。如果一個使用了@Inherited修飾的annotation型別被用於一個class，則這個annotation將被用於該class的子類。

使用此註解宣告出來的自定義註解，在使用此自定義註解時，如果註解在類上面時，子類會自動繼承此註解，否則的話，子類不會繼承此註解。這裡一定要記住，使用Inherited宣告出來的註解，只有在類上使用時才會有效，對方法，屬性等其他無效。

4. @Documented

一個簡單的Annotations標記註解，表示是否將註解資訊新增在java文件中。

表明這個註解應該被 javadoc工具記錄. 預設情況下,javadoc是不包括註解的。

示例：
在某個方法上增加了有Documented註解的元註解，則javadoc命令生成xxx.html檔案中。可以看到該註解。

註解元素

註解類中定義的元素稱為註解元素，註解元素可用的型別如下：
- 所有基本資料型別（int,float,boolean,byte,double,char,long,short)
- String型別
- Class型別
- enum型別
- Annotation型別
- 以上所有型別的陣列

實際使用注意問題

1. 使用註解不使用名字時，賦值規則，

  • 如果註解只有一個屬性，那麼肯定是賦值給該屬性。

  • 如果註解有多個屬性，而且前提是這多個屬性都有預設值，那麼你不寫註解名賦值，會賦值給名字為“value”這屬性。

  • 如果註解有多個屬性，其中有沒有設定預設值的屬性，那麼當你不寫屬性名進行賦值的時候，是會報錯的。

2. 若註解中定義了多個註解元素，除非註解元素使用的default。否則在使用該註解時，都需要賦值。

示例

1. 變數上的註解

1.1 註解定義

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FieldAnno {
    public String fileName() default "defaultFileName";
    public int value();

}
1.2 使用
public class MyAnno {
    @FieldAnno(111)
    private String myStr;
    ...
}    
1.3 呼叫 
 /**
     * 根據欄位名
     */
    public static void getFieldAnno() {
        try {
            Field myfiel = MyAnno.class.getDeclaredField("myStr");
//            myfiel.setAccessible(true);
            FieldAnno fieldAnno = myfiel.getAnnotation(FieldAnno.class);
            if (fieldAnno != null) {
                System.out.println("----getFieldAnno----");
                System.out.println(fieldAnno.fileName());
                System.out.println(fieldAnno.value());
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

     /**
     * 搜尋所有欄位
     */
    public static void getFieldAnno2() {

        Field[] fields = MyAnno.class.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(FieldAnno.class)) {
                FieldAnno fieldAnno = field.getAnnotation(FieldAnno.class);
                System.out.println("----getFieldAnno2----");
                System.out.println(fieldAnno.fileName());
                System.out.println(fieldAnno.value());
            }
        }


    }

2. 一般方法上的註解

2.1 定義
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodAnno {
    String methodNamett();
}
2.2 使用
@MethodAnno(methodNamett = "mycustomerMethod")
    private static void myMethod(){

    }
2.3 呼叫
 /**
     * 根據方法名獲取
     */
    public static void getMethodAnno() {
        try {

            Method myMethod = MyAnno.class.getDeclaredMethod("myMethod", MyAnno.class.getClasses());
            MethodAnno methodAnno = myMethod.getDeclaredAnnotation(MethodAnno.class);

            System.out.println(methodAnno.methodNamett());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查詢所有方法
     */
    public static void getMethodAnno2() {
        Method[] myMethods = MyAnno.class.getMethods();

        for (Method method : myMethods) {
            if(method.isAnnotationPresent(MethodAnno.class)){
                MethodAnno methodAnno = method.getDeclaredAnnotation(MethodAnno.class);
                System.out.println(methodAnno.methodNamett());
            }
        }

    }

3. 構造方法上的註解

3.1 定義

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface ConstructorAnno {

    boolean isDefault();
}

3.2 使用
@ConstructorAnno(isDefault = true)
    public MyAnno() {
    }

    @ConstructorAnno(isDefault = false)
    public MyAnno(String name) {
    }
3.3 呼叫
 /**
     * 根據指定名稱獲取
     */
    public static void getConAnno() {
        try {
            Constructor defaultConstructor = MyAnno.class.getDeclaredConstructor();
            ConstructorAnno constructorAnno=defaultConstructor.getDeclaredAnnotation(ConstructorAnno.class);
            System.out.println(constructorAnno.isDefault());

            Constructor Constructor = MyAnno.class.getDeclaredConstructor(String.class);
            ConstructorAnno constructorAnno2=Constructor.getDeclaredAnnotation(ConstructorAnno.class);
            System.out.println(constructorAnno2.isDefault());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

    }

    /**
     * 搜尋所有構造方法
     */
    public static void getConsAnno2() {
        Constructor[] myConstructors = MyAnno.class.getConstructors();

        for (Constructor constructor : myConstructors) {
            if (constructor.isAnnotationPresent(ConstructorAnno.class)) {
                ConstructorAnno constructorAnno = constructor.getDeclaredAnnotation(ConstructorAnno.class);
                System.out.println(constructorAnno.isDefault());
            }
        }
    }

4. 類上的註解

4.1 定義
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)//可以修飾class 和inteface
public @interface TypeAnno {
    String type();
}
4.2 使用
@TypeAnno(type="myTypeAnno")
public class MyAnno {
}
4.3 呼叫
  /**
     * 根據類名查詢該類的
     */
    public static void getTypeAnno() {

        TypeAnno typeAnno = MyAnno.class.getDeclaredAnnotation(TypeAnno.class);
        System.out.println(MyAnno.class.isAnnotationPresent(TypeAnno.class));
        System.out.println(typeAnno.type());

    }

    /**
     * 查詢包名下所有類
     */
    public static void getAnnoTypeAnno() {
        String basePackage = "com.myannotation";
        try {
            //先找到資源
            Enumeration<URL> enums = Thread.currentThread().getContextClassLoader().getResources(basePackage.replace(".", "/"));
            while (enums.hasMoreElements()) {
                URL uri = enums.nextElement();
                if ("file".equals(uri.getProtocol())) {//是否是檔案協議的檔案
                    String dirsStr = uri.getFile();//獲取檔案路徑
                    File dirsFile = new File(dirsStr);//建立File的資料夾物件
                    if (dirsFile.isDirectory()) {
                        File[] files = dirsFile.listFiles();//獲取該資料夾下所有檔案
                        for (File file : files) {
                            if (file.isFile()) {
                                String classname = basePackage + "." + file.getName();
                                classname = classname.substring(0, classname.length() - 6);
//                                System.out.println(classname);
                                Class clazz = Class.forName(classname);
                                if (clazz.isAnnotationPresent(TypeAnno.class)) {
                                    TypeAnno typeAnno = (TypeAnno) clazz.getDeclaredAnnotation(TypeAnno.class);
                                    System.out.println(typeAnno.type());
                                }
                            }
                        }
                    }
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

5. 區域性變數的註解

public void m(int a)  
@MyOwnAnnotation(some information)  
int b = 5;  
}

6. 引數上的註解

6.1 定義
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface  ParamAnno {
    String value() ;
}
6.2 使用
public static void meMethod(@ParamAnno("myvalue") String name1,String name2){
        @LocalVariableAnno()
        String tt;
    }
6.3 呼叫
 public static void getParamAnno() {
        try {
            Method method = MyAnno.class.getDeclaredMethod("meMethod", String.class, String.class);
            Annotation[][] paramss = method.getParameterAnnotations();
            for (Annotation[] parameterAnnotation : paramss) {
                for (Annotation annotation : parameterAnnotation) {
                    if (annotation instanceof ParamAnno) {
                        ParamAnno param = (ParamAnno) annotation;
                        System.out.println(param.value());
                    }
                }
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

    }

7. 包註解

作用
1、為標註在包上Annotation提供便利；
2、宣告包的私有類和常量；
* 3、提供包的整體註釋說明

8. ANNOTATION_TYPE

待續

9. TYPE_PARAMETER和TYPE_USE

Spring中使用的註解

AliasFor

給註解起別名。

參考

相關推薦

java 註解詳解+示例

註解介紹 1.5開始引入 註解可以理解為一種描述資料的資料，或者可以稱為一種描述元資料的方法。 java提供的預設註解：@Override，@Deprecated。 註解僅僅是元資料，和業務邏輯無關 定義方法在 java.lang.annotation包中

Java 註解詳解

一、什麼是註解 註解也叫元資料，例如我們常見的@Override和@Deprecated，註解是JDK1.5版本開始引入的一個特性，用於對程式碼進行說明，可以對包、類、介面、欄位、方法引數、區域性變數等進行註解 註解都預設繼承介面Annotation.jav

Java——註解詳解

Java註解同 classs 和 interface 一樣，註解也屬於一種型別。它是在 Java SE 5.0 版本中開始引入的概念。 註解的定義 通過 @interface 關鍵字進行定義。 public @interface TestAnnotation { } 這段程式碼就建立了一個名字為 Tes

Java註解詳解

一、介紹 1 概念 註解（Annotation），也叫元資料。一種程式碼級別的說明。它是Java 5新增的技術。要區別註釋，註解是程式碼裡的一種特殊標記，可在編譯前、編譯後、執行時等不同的時期被讀取，並作出相應的處理。 2 原則 由於註解的程式碼是附屬資訊，它

java註解詳解和自定義註解

本文首先介紹了註解的基本概念和JDK內建的標準註解，然後介紹瞭如何自定義註解，最後給出了自定義註解的例子。 一、註解的基本概念 Java 註解就像修飾符一樣，可以用於從java程式碼中抽取文件、跟蹤程式碼中的依賴性或者在編譯時做檢查。註解可以被應用在包、類、

Java註解詳解，自定義註解，利用反射解析註解

概要 這篇文章將會帶領你瞭解Java註解，註解的使用,註解的解析，利用反射解析執行時註解，相信有一定Java基礎的小夥伴一定會接觸大量的註解，Spring , Hibernate , MyBatis等著名的框架也有很多關於註解方面的應用，對於註解的使用小夥伴們

android&java註解詳解

package com.example.zwr.annotationdemo; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * author : zhongwr on 2016/12/1 * 獲取杯子的註解 */

JPA註解詳解及示例

文章出處：https://blog.csdn.net/zhengchao1991/article/details/70236919 1、用例項介紹JPA 使用JPA，肯定是有ORM的意思在裡面，當然我們首先要定義一個實體類（要將 Java 類指定為 JPA 實體，請使用 @Entity 批註

java元註解詳解

java中元註解有四個： @Retention @Target @Document @Inherited； 　　 @Retention：註解的保留位置　　　　　　　　　 　　　　　　@Retention(RetentionPolicy.SOURCE)   //註解僅

java自定義註解學習（二）_註解詳解

上篇文章，我們簡單的實現了一個自定義註解，相信大家對自定義註解有了個簡單的認識，這篇，這樣介紹下註解中的元註解和內值註解 整體圖示 內建註解 @Override 重寫覆蓋 這個註解大家應該經常用到，主要在子類重寫父類的方法，比如toString()方法 package com.kevin.demo;

Java程式設計之反射中的註解詳解

“註解”這個詞，可謂是在Java程式設計中出鏡率比較高，而且也是一個老生常談的話題。我們之前在聊Spring相關的東西時，註解是無處不在，之前我們簡單的聊過一些“註解”的相關內容，比如在Spring中是如何進行“註解”組合的。因為註解在Java程式設計中還是比較重要的，所以我們今天的部落格就把註解的東西給系統

Java學習系列(二十一)Java面向物件之註解詳解

一、前言 Java中的註解Annotation運用到很多方面，比如之前講的單元測試中的@Test、Spring、SpringMVC還有其他框架等等。Java本身自帶的註解也有一些，比如：@Override(子類要重寫/覆寫父類的對應方法)、@Deprecated(表

Java 執行時（RUNTIME）註解詳解

整理測試後並附上完整程式碼 註解定義 註解（Annotation），也叫元資料。一種程式碼級別的說明。它是JDK1.5及以後版本引入的一個特性，與類、介面、列舉是在同一個層次。它可以宣告在包、類、欄位、方法、區域性變數、方法引數等的前面，用來對這些元

java final詳解

inline mon 技術 但是 common src strac 都是 機制 final關鍵字 可用於聲明屬性、方法、和類 final類： final 類 不可被繼承，沒有子類，包括其中的方法默認都是final方法； final 類的方法不可被重寫，但是其中沒有被f

Java IO詳解

amr mst 數據丟失 網上 ria break idc png 字符串 學習Java的同學註意了！！！ 學習過程中遇到什麽問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：618528494 我們一起學Java！ 初學Java，一直搞不懂Java裏

Java synchronized詳解

ret 內置 etc 優先權 one lan string 作用域 靜態成員函數 轉自：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html 第一篇： 使用synchronized 在編寫一個

Java 反射詳解

什麽 tco type 性能 bob 參數 bject 今天 erl 　　反射反射，程序員的快樂，今天你快樂了嗎？如果你不快樂，沒關系，接下來讓你快樂起來！ 一、什麽是反射？　　通過百度百科我們可以知道，Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬

Java代理詳解

.get tle 理由 總結 ins 創建 set ota ble 一、概述 　　代理模式是Java常用的設計模式之一，實現代理模式要求代理類和委托類(被代理的類)具有相同的方法(提供相同的服務)，代理類對象自身並不實現真正的核心邏輯，而是通過調用委托類對象的相關方法來處

spark2.x由淺入深深到底系列六之RDD java api詳解二

spark 大數據 javaapi 老湯 rdd package com.twq.javaapi.java7; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaRDD; import org.

（轉）@RequestParam @RequestBody @PathVariable 等參數綁定註解詳解

erro 後綁定 false zip ons type() eba veh manager 引言： 接上一篇文章，對@RequestMapping進行地址映射講解之後，該篇主要講解request 數據到handler method 參數數據的綁定所用到的註解和什麽情形下使用