2. 程式人生 > 實用技巧 >深度分析：註解和反射，註解自定義與反射具體使用例項全幫你搞明白

深度分析：註解和反射，註解自定義與反射具體使用例項全幫你搞明白

阿新 • • 發佈：2020-08-14

前言

註解就是原始碼的元資料，通熟的講就是程式碼中的標籤。註解就有如下的特點：

  1. 註解是一個附屬品，依賴於其他元素（包、類、方法、屬性等等）存在。
  2. 註解本身沒有作用，在恰當的時候由外部程式進行解析才會發生作用。

註解有哪些？

  1. 按來源分
    • JDK 自帶註解，例如：@Override, @Deprecated, @SuppressWornings 。
    • 第三方註解。
    • 自定義註解。
  2. 按生命週期劃分
    • SOURCE：只存在於原始碼中，編譯成 class 檔案就不存在了。
    • Class：存在於原始碼中和 class 檔案中。
    • RUNTIME：註解保留到執行時。

什麼是元註解？

元註解指的是用於構成註解的註解，包括如下幾個：

  1. @Retention：指明 Annotation 的生命週期，傳入的值是一個列舉型別，可選值為：
    • RetentionPolicy.SOURCE
    • RetentionPolicy.CLASS
    • RetentionPolicy.RUNTIME
  2. @Target：指明 Annotation 可以修飾程式哪些元素，傳入的值為ElemetType[] 型別，值可為：
    • ElementType.CONSTRUCTOR ：構造器
    • ElementType.FIELD：屬性
    • ElementType.LOCAL_VARIABLE：區域性變數
    • ElementType.METHOD：方法
    • ElementType.PACKAGE
      ：包
    • ElementType.PARAMETER：引數
    • ElementType.TYPE：類、介面（包括註解型別和 enum 宣告）
  3. @Documented：使用此修飾的註解將會被 javadoc 工具提取成文件，使用此註解，其 @Retention 必須被設定為 RetentionPolicy.RUNTIME 。
  4. @Inherited：具有繼承性。

如何自定義註解？

自定義註解需要注意的問題：

  1. 使用 @interface 關鍵字定義。

  2. 自動繼承 java.lang.annotation.Annotation 介面。

  3. 配置引數的型別只能是八大基本型別、String、Class、enum、Annotation 和對應的陣列型別。

  4. 配置引數宣告的語法格式如下（[] 表示可省略）：

    型別 變數名() [default 預設值];

  5. 如果只有一個配置引數，其引數名必須為 value。

  6. 如果定義的註解含有配置引數，那在使用註解時，必須指定引數值，指定形式為：“引數名=引數值”。如果只有一個引數，直接寫引數值即可，定義中指定了預設值的引數可以不指定值，但沒有的一定要指定值。

  7. 沒有成員的註解為標記，包含成員的稱為元資料。

自定義註解例項（定義和使用）

參考程式碼：

（1）Test01.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class Test01 {
    @Info(name = "張三",address="北京")
    public void test01(){

    }
    @One("value")
    public void test02(){

    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE,ElementType.METHOD})
    @interface Info {
        String name();
        String address();

        int age()default 18;
    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD})
    @interface One{
        String value();
    }
}

反射

什麼是反射？

反射指的是程式在執行期間藉助反射 API 取得任何類的內部資訊，並通過這些內部資訊去操作對應物件的內部屬性和方法。

任何一個類，在第一次使用時，就會被 JVM 載入到堆記憶體的方法區中。JVM 載入類成功後，就會在方法區中產生一個對應的 Class 物件（一個類只要一個 Class 物件），這個 Class 物件包含被載入類的全部結構資訊。

如何獲取class物件？

（1）類的 class 屬性

每一個類，都有一個 class 靜態屬性，這個靜態屬性就是類對應的 Class 物件。

1 Class<Person> cl1 = Person.class;

（2）Object 物件 的 getClass() 方法

1 Person p1 = new Person()；
2 Class<Person> cl2 = (Class<Person>) p1.getClass();

（3）通過 Class 類的 forName() 方法（最常用）

1 try {
2     Class cl3 = Class.forName("com.llm.hkl.Person");
3 } catch (ClassNotFoundException e) {
4     e.printStackTrace();
5 }

（4）通過 ClassLoader 類（不常用）

1 ClassLoader cl = Person.class.getClassLoader();
2 try {
3     Class cl4 = cl.loadClass("com.llm.hkl.Person");
4 } catch (ClassNotFoundException e) {
5     e.printStackTrace();
6 }

如何使用反射？

反射的基本使用包括建立物件，設定屬性和呼叫方法。Class 物件中大多數 get 方法有 Declared 和無 Declared，他們的區別是：

  1. 無 Declared：只能獲取到 public 修飾的，包括當前類和所有父類。
  2. 有 Declared：獲取到當前類所有的（含有 private），但不包括其父類。

反射例項：

Person類和註解類（準備）：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Info(name = "張三", habbit = "程式設計")
public class Person {
    @Filed("張三")
    private String name;
    public String habbit;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getHabbit() {
        return habbit;
    }

    public void setHabbit(String habbit) {
        this.habbit = habbit;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", habbit='" + habbit + '\'' +
                ", age=" + age +
                '}';
    }

    private String say(String str) {
        String str1 = name + "說：" + str;
        System.out.println(str1);
        return str1;
    }

    public void eat(String food) {
        System.out.println(name + "吃" + food);
    }

    public Person() {

    }

    public Person(String name, String habbit, int age) {
        this.name = name;
        this.habbit = habbit;
        this.age = age;
    }

    private Person(String name, String habbit) {
        this.name = name;
        this.habbit = habbit;
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD, ElementType.TYPE})
    @interface Info {
        String name();

        String habbit();

        int age() default 18;
    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    @interface Filed{
        String value();
    }
}

reflect用法一（獲取類的基本資訊)：

獲得類的名字
獲得類的屬性
獲得指定屬性的值
獲得類的方法
獲得指定方法
獲取構造器
獲得指定的構造器

 Class<?> person = Class.forName("Person");
        //獲得類的名字
        System.out.println("<-----------------------------------獲得類的名字-------------------------->");
        String name = person.getName();
        System.out.println(name);

        //獲得類的屬性
        System.out.println("<-------------------------------------獲得類的屬性--------------------->");
            //僅public
        System.out.println("<-----------------getFields----------------->");
        Field[] fields = person.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("<-----------------getDeclaredFields----------------->");
        Field[] declaredFields = person.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        //獲得指定屬性的值
        System.out.println("<--------------------獲得類的指定屬性--------------------------------------->");
        Field name1 = person.getDeclaredField("name");
        System.out.println(name1);

        //獲得類的方法
        System.out.println("<--------------------獲得類的方法--------------------------------------->");
            //僅public
        System.out.println("<-----------------getMethods----------------->");
        Method[] methods = person.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("<-----------------getDeclaredMethods----------------->");
        Method[] declaredMethods = person.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        //獲得指定方法
        System.out.println("<-------------------------獲得類的指定方法--------------------------------------->");
        Method say = person.getDeclaredMethod("say",String.class);
        System.out.println(say);

        //獲取構造器
        System.out.println("<--------------------------獲得類的構造器--------------------------------->");
        System.out.println("<-----------------getConstructors----------------->");
            //僅public
        Constructor<?>[] constructors = person.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("<-----------------getDeclaredConstructors----------------->");
        Constructor<?>[] declaredConstructors = person.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        //獲得指定的構造器
        System.out.println("<---------------------------獲得類指定的構造器------------------------------>");
        Constructor<?> declaredConstructor = person.getDeclaredConstructor(String.class, String.class, int.class);
        System.out.println(declaredConstructor);

reflect用法二（建立並操作物件）：

反射方式建立物件
呼叫無參構造器建立物件
通過有參構造器
通過私有的構造器
通過反射設定公有屬性
通過反射設定私有屬性
通過反射呼叫方法
通過反射呼叫私有方法

Class<?> person = Class.forName("Person");

        //  反射方式建立物件
        System.out.println("<-----反射方式建立物件----->");
        Person instance01 = (Person) person.newInstance();
        System.out.println(instance01);

        //  呼叫無參構造器建立物件
        System.out.println("<-----呼叫無參構造器建立物件----->");
        Constructor<?> noneConstructor = person.getDeclaredConstructor();
        Person instance02 = (Person) noneConstructor.newInstance();
        System.out.println(instance02);

        //  呼叫有參構造器建立物件
        System.out.println("<-----呼叫有參構造器建立物件----->");
        Constructor<?> constructor = person.getDeclaredConstructor(String.class, String.class, int.class);
        Person instance03 = (Person) constructor.newInstance("張三", "程式設計", 18);
        System.out.println(instance03);

        //  呼叫私有的構造器建立物件
        System.out.println("<-----呼叫私有的構造器建立物件----->");
        java.lang.reflect.Constructor<?> privateConstructor = person.getDeclaredConstructor(String.class, String.class);
        privateConstructor.setAccessible(true);
        Object instance04 = privateConstructor.newInstance("張三", "程式設計");
        System.out.println(instance04);

        //  通過反射設定公有屬性
        System.out.println("<-----通過反射設定公有屬性----->");
        Field habbit = person.getDeclaredField("habbit");
        habbit.set(instance01, "程式設計");
        System.out.println(instance01);

        //  通過反射設定私有屬性
        System.out.println("<-----通過反射設定私有屬性----->");
        Field name = person.getDeclaredField("name");
        name.setAccessible(true);
        name.set(instance01, "張三");
        System.out.println(instance01);
        //  通過反射呼叫公有方法
        System.out.println("<-----通過反射調公用方法----->");
        Method eat = person.getDeclaredMethod("eat", String.class);
        eat.invoke(instance01,"飯");
        //  通過反射呼叫私有方法
        System.out.println("<-----通過反射呼叫私有方法----->");
        Method say = person.getDeclaredMethod("say", String.class);
        say.setAccessible(true);
        say.invoke(instance01,"呵呵");

reflect用法三（獲取泛型資訊）：

Java採用泛型擦除的機制來引入泛型,Java中的泛型僅僅是給編譯器 Javac使用的,確保資料的安全性和免去強制型別轉換問題,但是,一旦編譯完成,所有和泛型有關的型別全部擦除。
為了通過反射操作這些型別,Java新增了 ParameterizedType, GenericArrayTypeType Variable和 WildcardType幾種型別來代表不能被歸一到class類中的型別但是又和原始型別齊名的型別。

ParameterizedType:表示一種引數化型別比如 Collection< String>

GenericArrayType:表示種元素型別是引數化型別或者型別變數的陣列型別

TypeVariable:是各種型別變數的公共父介面

WildcardType:代表種萬用字元型別表示式

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

public class Test03 {
    public void test01(Map<String, Person> map, List<Person> list) {
        System.out.println("test01");
    }
    public Map<String, Person> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws Exception {
        Class<Test03> test03 = Test03.class;

        System.out.println("<--------test01---------->");
        Method test01 = test03.getDeclaredMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println("<--------test02---------->");
        Method test02 = test03.getDeclaredMethod("test02");
        Type genericReturnType = test02.getGenericReturnType();
        System.out.println(genericReturnType);
        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

執行結果:

reflect用法四（獲取註解資訊）：

獲取類上的註解
獲取屬性上的註解
獲取方法上的註解

		Class<?> person = Class.forName("Person");
        System.out.println("<----------獲取類上的註解------------->");
        //獲取類上的註解
        Info annotation = person.getAnnotation(Info.class);
        System.out.println(annotation.name());
        System.out.println(annotation.habbit());
        System.out.println(annotation.age());

        System.out.println("<----------獲取屬性上的註解------------->");
        //獲取屬性上的註解
        Field name = person.getDeclaredField("name");
        Person.Filed file = name.getAnnotation(Person.Filed.class);
        String value = file.value();
        System.out.println(value);
        //獲取方法上的註解  略。。。

執行結果：

最後

感謝你看到這裡，看完有什麼的不懂的可以在評論區問我，覺得文章對你有幫助的話記得給我點個贊，每天都會分享java相關技術文章或行業資訊，歡迎大家關注和轉發文章！

相關推薦

深度分析：註解和反射，註解自定義與反射具體使用例項全幫你搞明白

前言 註解就是原始碼的元資料，通熟的講就是程式碼中的標籤。註解就有如下的特點：

看阿里P7講MyBatis：從MyBatis的理解以及配置和實現全幫你搞懂

前言 MyBatis 是一款優秀的持久層框架，一個半 ORM（物件關係對映）框架，它支援定製化 SQL、儲存過程以及高階映`射。MyBatis 避免了幾乎所有的 JDBC 程式碼和手動設定引數以及獲取結果集。MyBatis 可以使用簡單的 X

NZXT 釋出新款 Function 鍵盤：外型簡潔低調，可自定義鍵盤軸體

3 月 16 日訊息，NZXT 今日釋出了一款 Function 機械鍵盤，外型簡潔低調的鋁製機械鍵盤，主打讓使用者根據個人喜好來客製化鍵盤。官方表示，這款鍵盤包含了鍵盤玩家社群不斷在追尋的客制功能如：熱插拔軸體、可拆卸

萬字長文帶你掌握Java陣列與排序，程式碼實現原理都幫你搞明白！

查詢元素索引位置 基本查詢 根據陣列元素找出該元素第一次在陣列中出現的索引

徹底幫你搞明白vue計算屬性computed和methods的區別

技術標籤：Vue.jsvuejsjavascript 先來一段程式碼，我們分別宣告一個methods方法newName()，computed新增一個計算屬性newNames，然後分別在頁面中調了各四次，我們來看一下列印結果：如下圖

java註解與反射之分析效能，普通方式呼叫與反射呼叫與關閉檢測的反射呼叫：狂神說筆記

技術標籤：# 註解與反射需理解反射java 通過程式碼的方式來檢驗三種方式呼叫的效率

深度分析：java8的新特性lambda和stream流，看完你學會了嗎？

1. lambda表示式 1.1 什麼是lambda 以java為例，可以對一個java變數賦一個值，比如int a = 1，而對於一個方法，一塊程式碼也是賦予給一個變數的，對於這塊程式碼，或者說被賦給變數的函式，就是一個lambda表示式

深度分析：面試阿里，位元組跳動，美團幾乎都會被問到的阻塞佇列

基本概念 阻塞佇列（BlockingQueue）是一個支援兩個附加操作的佇列。這兩個附加的操作支援阻塞的插入和移除方法。1）支援阻塞的插入方法：意思是當佇列滿時，佇列會阻塞插入元素的執行緒，直到佇列不滿。

深度分析：面試阿里，位元組跳動，美團90%被問到的List集合，看完還不懂算我輸

1 List集合 1.1 List概述 在Collection中，List集合是有序的，可對其中每個元素的插入位置進行精確地控制，可以通過索引來訪問元素，遍歷元素。

Spring基礎：自動配置bean，註解實現自動裝配（重要）

1，bean的自動裝配 　　自動裝配是Spring滿足bean依賴的一種方式 　　Spring會在上下文中自動尋找，並自動給裝配屬性

二.5 java高階-反射，註解，泛型

一.泛型 1.定義：泛型的本質是引數化型別，就是將型別引數化。限制資料元素的資料型別，提供了編譯時的安全檢查

深度分析 2999 名中國人基因，中科院釋出“女媧”資料集：中國人專屬，填補國際研究空白

11 月 28 日訊息，遺傳變異圖譜是研究人群演化史、醫學遺傳學、基因型－表型關聯的基礎。此前，大多數全基因組測序相關研究主要集中在歐洲血統人群。已有研究表明，罕見和低頻的變異往往特定於人群或樣本，尤其是與

java面試必問：多執行緒的實現和同步機制，一文幫你搞定多執行緒程式設計

前言 程序：一個計算機程式的執行例項，包含了需要執行的指令；有自己的獨立地址空間，包含程式內容和資料；不同程序的地址空間是互相隔離的；程序擁有各種資源和狀態資訊，包括開啟的檔案、子程序和訊號處理。

nextTick原始碼分析：MutationObserver和MessageChannel

為什麼要用nextTick <!DOCTYPE html> <html lang=\"en\"> <head> <meta charset=\"UTF-8\">

深度學習：MAE 和 RMSE 詳解

https://blog.csdn.net/nanhuaibeian/article/details/102746602 平均絕對誤差MAE（mean absolute error） 和均方根誤差 RMSE（root mean squared error)是衡量變數精度的兩個最常用的指標，同時也是機器學習中評價

033：strong和weak，（strong=retain+release）weak（self指標地址和weakSelf地址不一樣、 weakSelf沒有對引用計數+1）

問題 當前self取地址 和weakSelf取地址的值是不一樣的 weakSelf沒有對記憶體進行+1操作

深度學習程式碼入門（二）：tf下的Keras介面，非自定義網路初步實現

技術標籤：深度學習 from tensorflow.keras import layers # 匯入常見網路層類 匯入常見網路層，比如說常用的非線性啟用函式relu、softmax都可以。

【IT之家評測室】OPPO Find X3 Pro 深度體驗：感受為王，觀感旗艦

時隔一年，OPPO Find 旗艦機終於和我們見面了，在官方的宣傳中，全新的 OPPO Find X3 Pro 為定義為 “色彩影像旗艦”，Find X3 Pro 搭載了全鏈路 10bit 色彩引擎、10 億色雙主攝、10 億色臻彩屏，實現了 10bit 從拍攝

springboot專案編譯時，使用自定義註解類找不到符號

Java專案編譯時，使用自定義註解類找不到符號 Spring-boot專案 編輯器：idea 問題：編譯時找不到符號。專案中用到了自定義註解類。編輯器不提示語法有錯誤

同類中不帶註解的方法呼叫帶註解的方法，註解失效？

正好工作中遇到的問題，在這裡記錄。 一、問題背景： 自定義的註解，在方法攔截器中進行攔截，必須在同類實行巢狀呼叫，而且不能改動呼叫方式。