小白都能學會的Java註解與反射機制

陳皮的JavaLib發表於2021-04-07

前言

Java註解和反射是很基礎的Java知識了，為何還要講它呢？因為我在面試應聘者的過程中，發現不少面試者很少使用過註解和反射，甚至有人只能說出@Override這一個註解。我建議大家還是儘量能在開發中使用註解和反射，有時候使用它們能讓你事半功倍，簡化程式碼提高編碼的效率。很多優秀的框架都基本使用了註解和反射，在Spring AOP中，就把註解和反射用得淋漓盡致。

什麼是註解

Java註解（Annotation）亦叫Java標註，是JDK5.0開始引入的一種註釋機制。註解可以用在類、介面，方法、變數、引數以及包等之上。註解可以設定存在於不同的生命週期中，例如SOURCE（原始碼中），CLASS（Class檔案中，預設是此保留級別），RUNTIME（執行期中）。

註解以@註解名的形式存在於程式碼中，Java中內建了一些註解，例如@Override，當然我們也可以自定義註解。註解也可以有引數，例如@MyAnnotation(value = "陳皮")。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

那註解有什麼作用呢？其一是作為一種輔助資訊，可以對程式做出一些解釋，例如@Override註解作用於方法上，表示此方法是重寫了父類的方法。其二，註解可以被其他程式讀取，例如編譯器，例如編譯器會對被@Override註解的方法檢測判斷方法名和引數等是否與父類相同，否則會編譯報錯；而且在執行期可以通過反射機制訪問某些註解資訊。

內建註解

Java中有10個內建註解，其中6個註解是作用在程式碼上的，4個註解是負責註解其他註解的(即元註解)，元註解提供對其他註解的型別說明。

註解	作用	作用範圍
@Override	檢查該方法是否是重寫方法。如果其繼承的父類或者實現的介面中並沒有該方法時，會報編譯錯誤。	作用在程式碼上
@Deprecated	標記表示過時的，不推薦使用。可以用於修飾方法，屬性，類。如果使用被此註解修飾的方法，屬性或類，會報編譯警告。	作用在程式碼上
@SuppressWarnings	告訴編譯器忽略註解中宣告的警告。	作用在程式碼上
@SafeVarargs	Java 7開始支援，忽略任何使用引數為泛型變數的方法或建構函式呼叫產生的警告。	作用在程式碼上
@FunctionalInterface	Java 8開始支援，標識一個匿名函式或函式式介面。	作用在程式碼上
@Repeatable	Java 8開始支援，標識某註解可以在同一個宣告上使用多次。	作用在程式碼上
@Retention	標識這個註解的儲存級別，是隻在程式碼中，還是編入class檔案中，或者是在執行時可以通過反射訪問。包含關係runtime>class>source。	作用在其他註解上，即元註解
@Documented	標記這些註解是否包含在使用者文件中javadoc。	作用在其他註解上，即元註解
@Target	標記某個註解的使用範圍，例如作用方法上，類上，屬性上等等。如果註解未使用@Target，則註解可以用於任何元素上。	作用在其他註解上，即元註解
@Inherited	說明子類可以繼承父類中的此註解，但這不是真的繼承，而是可以讓子類Class物件使用getAnnotations()獲取父類被@Inherited修飾的註解	作用在其他註解上，即元註解

自定義註解

使用@interface關鍵字自定義註解，其實底層就是定義了一個介面，而且自動繼承java.lang.annotation.Annotation介面。

我們自定義一個註解如下：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    String value();
}

我們使用命令javap反編譯我們定義的MyAnnotation註解的class檔案，結果顯示如下。雖然註解隱式繼承了Annotation介面，但是Java不允許我們顯示通過extends關鍵字繼承Annotation介面甚至其他介面，否則編譯報錯。

D:\>javap MyAnnotation.class
Compiled from "MyAnnotation.java"
public interface com.nobody.MyAnnotation extends java.lang.annotation.Annotation {
  public abstract java.lang.String value();
}

註解的定義內容如下：

格式為public @interface 註解名 {定義內容}
內部的每一個方法實際是宣告瞭一個引數，方法的名稱就是引數的名稱。
返回值型別就是引數的型別，而且返回值型別只能是基本型別（int，float，long，short，boolean，byte，double，char），Class，String，enum，Annotation以及上述型別的陣列形式。
如果定義了引數，可通過default關鍵字宣告引數的預設值，若不指定預設值，使用時就一定要顯示賦值，而且不允許使用null值，一般會使用空字串或者0。
如果只有一個引數，一般引數名為value，因為使用註解時，賦值可以不顯示寫出引數名，直接寫引數值。

import java.lang.annotation.*;

/**
 * @Description 自定義註解
 * @Author Mr.nobody
 * @Date 2021/3/30
 * @Version 1.0
 */
@Target(ElementType.METHOD) // 此註解只能用在方法上。
@Retention(RetentionPolicy.RUNTIME) // 此註解儲存在執行時期，可以通過反射訪問。
@Inherited // 說明子類可以繼承此類的此註解。
@Documented // 此註解包含在使用者文件中。
public @interface CustomAnnotation {
    String value(); // 使用時需要顯示賦值
    int id() default 0; // 有預設值，使用時可以不賦值
}

/**
 * @Description 測試註解
 * @Author Mr.nobody
 * @Date 2021/3/30
 * @Version 1.0
 */
public class TestAnnotation {

    // @CustomAnnotation(value = "test") 只能註解在方法上，這裡會報錯
    private String str = "Hello World!";

    @CustomAnnotation(value = "test")
    public static void main(String[] args) {
        System.out.println(str);
    }
}

Java8 註解

在這裡講解下Java8之後的幾個註解和新特性，其中一個註解是@FunctionalInterface，它作用在介面上，標識是一個函式式介面，即只有有一個抽象方法，但是可以有預設方法。

@FunctionalInterface
public interface Callback<P,R> {

    public R call(P param);
}

還有一個註解是@Repeatable，它允許在同一個位置使用多個相同的註解，而在Java8之前是不允許的。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(OperTypes.class)
public @interface OperType {
    String[] value();
}

// 可以理解@OperTypes註解作為接收同一個型別上重複@OperType註解的容器
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperTypes {
    OperType[] value();
}

@OperType("add")
@OperType("update")
public class MyClass {
    
}

注意，對於重複註解，不能再通過clz.getAnnotation(Class<A> annotationClass)方法來獲取重複註解，Java8之後，提供了新的方法來獲取重複註解，即clz.getAnnotationsByType(Class<A> annotationClass)方法。

package com.nobody;

import java.lang.annotation.Annotation;

/**
 * @Description
 * @Author Mr.nobody
 * @Date 2021/3/31
 * @Version 1.0
 */
@OperType("add")
@OperType("update")
public class MyClass {

    public static void main(String[] args) {
        Class<MyClass> clz = MyClass.class;
        Annotation[] annotations = clz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation.toString());
        }

        OperType operType = clz.getAnnotation(OperType.class);
        System.out.println(operType);

        OperType[] operTypes = clz.getAnnotationsByType(OperType.class);
        for (OperType type : operTypes) {
            System.out.println(type.toString());
        }
    }

}

// 輸出結果為
@com.nobody.OperTypes(value=[@com.nobody.OperType(value=[add]), @com.nobody.OperType(value=[update])])
null
@com.nobody.OperType(value=[add])
@com.nobody.OperType(value=[update])

在Java8中，ElementType列舉新增了兩個列舉成員，分別為TYPE_PARAMETER和TYPE_USE，TYPE_PARAMETER標識註解可以作用於型別引數，TYPE_USE標識註解可以作用於標註任意型別(除了Class)。

Java反射機制

我們先了解下什麼是靜態語言和動態語言。動態語言是指在執行時可以改變其自身結構的語言。例如新的函式，物件，甚至程式碼可以被引進，已有的函式可以被刪除或者結構上的一些變化。簡單說即是在執行時程式碼可以根據某些條件改變自身結構。動態語言主要有C#，Object-C，JavaScript，PHP，Python等。靜態語言是指執行時結構不可改變的語言，例如Java，C，C++等。

Java不是動態語言，但是它可以稱為準動態語言，因為Java可以利用反射機制獲得類似動態語言的特性，Java的動態性讓它在程式設計時更加靈活。

反射機制允許程式在執行期藉助於Reflection API取得任何類的內部資訊，並能直接操作任意物件的內部屬性以及方法等。類在被載入完之後，會在堆記憶體的方法區中生成一個Class型別的物件，一個類只有一個Class物件，這個物件包含了類的結構資訊。我們可以通過這個物件看到類的結構。

比如我們可以通過Class clz = Class.forName("java.lang.String");獲得String類的Class物件。我們知道每個類都隱式繼承Object類，Object類有個getClass()方法也能獲取Class物件。

Java反射機制提供的功能

在執行時判斷任意一個物件所屬的類
在執行時構造任意一個類的物件
在執行時判斷任意一個類具有的成員變數和方法
在執行時獲取泛型資訊
在執行時呼叫任意一個物件的成員變數和方法
在執行時獲取註解
生成動態代理
...

Java反射機制的優缺點

優點：實現動態建立物件和編譯，有更加的靈活性。
缺點：對效能有影響。使用反射其實是一種解釋操作，即告訴JVM我們想要做什麼，然後它滿足我們的要求，所以總是慢於直接執行相同的操作。

Java反射相關的主要API

java.lang.Class：代表一個類
java.lang.reflect.Method：代表類的方法
java.lang.reflect.Field：代表類的成員變數
java.lang.reflect.Constructor：代表類的構造器

我們知道在執行時通過反射可以準確獲取到註解資訊，其實以上類（Class，Method，Field，Constructor等）都直接或間接實現了AnnotatedElement介面，並實現了它定義的方法，AnnotatedElement介面的作用主要用於表示正在JVM中執行的程式中已使用註解的元素，通過該介面提供的方法可以獲取到註解資訊。

java.lang.Class 類

在Java反射中，最重要的是Class這個類了。Class本身也是一個類。當程式想要使用某個類時，如果此類還未被載入到記憶體中，首先會將類的class檔案位元組碼載入到記憶體中，並將這些靜態資料轉換為方法區的執行時資料結構，然後生成一個Class型別的物件（Class物件只能由系統建立），一個類只有一個Class物件，這個物件包含了類的結構資訊。我們可以通過這個物件看到類的結構。每個類的例項都會記得自己是由哪個Class例項所生成的。

通過Class物件可以知道某個類的屬性，方法，構造器，註解，以及實現了哪些介面等資訊。注意，只有class，interface，enum，annotation，primitive type，void，[] 等才有Class物件。

package com.nobody;

import java.lang.annotation.ElementType;
import java.util.Map;

public class TestClass {

    public static void main(String[] args) {

        // 類
        Class<MyClass> myClassClass = MyClass.class;
        // 介面
        Class<Map> mapClass = Map.class;
        // 列舉
        Class<ElementType> elementTypeClass = ElementType.class;
        // 註解
        Class<Override> overrideClass = Override.class;
        // 原生型別
        Class<Integer> integerClass = Integer.class;
        // 空型別
        Class<Void> voidClass = void.class;
        // 一維陣列
        Class<String[]> aClass = String[].class;
        // 二維陣列
        Class<String[][]> aClass1 = String[][].class;
        // Class類也有Class物件
        Class<Class> classClass = Class.class;

        System.out.println(myClassClass);
        System.out.println(mapClass);
        System.out.println(elementTypeClass);
        System.out.println(overrideClass);
        System.out.println(integerClass);
        System.out.println(voidClass);
        System.out.println(aClass);
        System.out.println(aClass1);
        System.out.println(classClass);
    }
}

// 輸出結果
class com.nobody.MyClass
interface java.util.Map
class java.lang.annotation.ElementType
interface java.lang.Override
class java.lang.Integer
void
class [Ljava.lang.String;
class [[Ljava.lang.String;
class java.lang.Class

獲取Class物件的方法

如果知道具體的類，可通過類的class屬性獲取，這種方法最安全可靠並且效能最高。Class clz = User.class;
通過類的例項的getClass()方法獲取。Class clz = user.getClass();
如果知道一個類的全限定類名，並且在類路徑下，可通過Class.forName()方法獲取，但是可能會丟擲ClassNotFoundException。Class clz = Class.forName("com.nobody.User");
內建的基本資料型別可以直接通過類名.Type獲取。Class<Integer> clz = Integer.TYPE;
通過類載入器ClassLoader獲取

Class類的常用方法

public static Class<?> forName(String className)：建立一個指定全限定類名的Class物件
public T newInstance()：呼叫Class物件所代表的類的無參構造方法，建立一個例項
public String getName()：返回Class物件所代表的類的全限定名稱。
public String getSimpleName()：返回Class物件所代表的類的簡單名稱。
public native Class<? super T> getSuperclass()：返回Class物件所代表的類的父類的Class物件，這是一個本地方法
public Class<?>[] getInterfaces()：返回Class物件的介面
public Field[] getFields()：返回Class物件所代表的實體的public屬性Field物件陣列
public Field[] getDeclaredFields()：返回Class物件所代表的實體的所有屬性Field物件陣列
public Field getDeclaredField(String name)：獲取指定屬性名的Field物件
public Method[] getDeclaredMethods()：返回Class物件所代表的實體的所有Method物件陣列
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回指定名稱和引數型別的Method物件
myClassClass.getDeclaredConstructors();：返回所有Constructor物件的陣列
public ClassLoader getClassLoader()：返回當前類的類載入器

在反射中經常會使用到Method的invoke方法，即public Object invoke(Object obj, Object... args)，我們簡單說明下：

第一個Object對應原方法的返回值，若原方法沒有返回值，則返回null。
第二個Object物件對應呼叫方法的例項，若原方法為靜態方法，則引數obj可為null。
第二個Object對應若原方法形參列表，若引數為空，則引數args為null。
若原方法宣告為private修飾，則呼叫invoke方法前，需要顯示呼叫方法物件的method.setAccessible(true)方法，才可訪問private方法。

反射操作泛型

泛型是JDK 1.5的一項新特性，它的本質是引數化型別（Parameterized Type）的應用，也就是說所操作的資料型別被指定為一個引數，在用到的時候再指定具體的型別。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面和泛型方法。

在Java中，採用泛型擦除的機制來引入泛型，泛型能編譯器使用javac時確保資料的安全性和免去強制型別轉換問題，泛型提供了編譯時型別安全檢測機制，該機制允許程式設計師在編譯時檢測到非法的型別。並且一旦編譯完成，所有和泛型有關的型別會被全部擦除。

Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType等幾種型別，能讓我們通過反射操作這些型別。

ParameterizedType：表示一種引數化型別，比如Collection<String>
GenericArrayType：表示種元素型別是引數化型別或者型別變數的陣列型別
TypeVariable：是各種型別變數的公共父介面
WildcardType：代表種萬用字元型別表示式

package com.nobody;

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

public class TestReflectGenerics {

    public Map<String, Person> test(Map<String, Integer> map, Person person) {
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        // 獲取test方法物件
        Method test = TestReflectGenerics.class.getDeclaredMethod("test", Map.class, Person.class);
        // 獲取方法test的引數型別
        Type[] genericParameterTypes = test.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);
                }
            }
        }

        // 獲取方法test的返回值型別
        Type genericReturnType = test.getGenericReturnType();
        System.out.println("返回值型別：" + genericReturnType);
        // 如果引數型別等於引數化型別
        if (genericReturnType instanceof ParameterizedType) {
            // 獲得真實引數型別
            Type[] actualTypeArguments =
                    ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("    " + actualTypeArgument);
            }
        }

    }
}

class Person {}

// 輸出結果
方法引數型別：java.util.Map<java.lang.String, java.lang.Integer>
    class java.lang.String
    class java.lang.Integer
方法引數型別：class com.nobody.Person
返回值型別：java.util.Map<java.lang.String, com.nobody.Person>
    class java.lang.String
    class com.nobody.Person

反射操作註解

在Java執行時，通過反射獲取程式碼中的註解是比較常用的手段了，獲取到了註解之後，就能知道註解的所有資訊了，然後根據資訊進行相應的操作。下面通過一個例子，獲取類和屬性的註解，解析對映為資料庫中的表資訊。

package com.nobody;

import java.lang.annotation.*;

public class AnalysisAnnotation {

    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("com.nobody.Book");
        // 獲取類的指定註解，並且獲取註解的值
        Table annotation = aClass.getAnnotation(Table.class);
        String value = annotation.value();
        System.out.println("Book類對映的資料庫表名：" + value);

        java.lang.reflect.Field bookName = aClass.getDeclaredField("bookName");
        TableField annotation1 = bookName.getAnnotation(TableField.class);
        System.out.println("bookName屬性對映的資料庫欄位屬性 - 列名：" + annotation1.colName() + ",型別："
                + annotation1.type() + ",長度：" + annotation1.length());
        java.lang.reflect.Field price = aClass.getDeclaredField("price");
        TableField annotation2 = price.getAnnotation(TableField.class);
        System.out.println("price屬性對映的資料庫欄位屬性 - 列名：" + annotation2.colName() + ",型別："
                + annotation2.type() + ",長度：" + annotation2.length());
    }
}

// 作用於類的註解，用於解析表資料
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    // 表名
    String value();
}

// 作用於欄位，用於解析表列
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableField {
    // 列名
    String colName();

    // 列型別
    String type();

    // 長度
    int length();
}

@Table("t_book")
class Book {
    @TableField(colName = "name", type = "varchar", length = 15)
    String bookName;
    @TableField(colName = "price", type = "int", length = 10)
    int price;
}

// 輸出結果
Book類對映的資料庫表名：t_book
bookName屬性對映的資料庫欄位屬性 - 列名：name,型別：varchar,長度：15
price屬性對映的資料庫欄位屬性 - 列名：price,型別：int,長度：10

效能分析

前面我們說過，反射對效能有一定影響。因為反射是一種解釋操作，它總是慢於直接執行相同的操作。而且Method，Field，Constructor都有setAccessible()方法，它的作用是開啟或禁用訪問安全檢查。如果我們程式程式碼中用到了反射，而且此程式碼被頻繁呼叫，為了提高反射效率，則最好禁用訪問安全檢查，即設定為true。

package com.nobody;

import java.lang.reflect.Method;

public class TestReflectSpeed {

    // 10億次
    private static int times = 1000000000;

    public static void main(String[] args) throws Exception {
        test01();
        test02();
        test03();
    }

    public static void test01() {
        Teacher t = new Teacher();
        long start = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            t.getName();
        }
        long end = System.currentTimeMillis();
        System.out.println("普通方式執行10億次消耗：" + (end - start) + "ms");
    }

    public static void test02() throws Exception {
        Teacher teacher = new Teacher();
        Class<?> aClass = Class.forName("com.nobody.Teacher");
        Method getName = aClass.getDeclaredMethod("getName");
        long start = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            getName.invoke(teacher);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射方式執行10億次消耗：" + (end - start) + "ms");
    }

    public static void test03() throws Exception {
        Teacher teacher = new Teacher();
        Class<?> aClass = Class.forName("com.nobody.Teacher");
        Method getName = aClass.getDeclaredMethod("getName");
        getName.setAccessible(true);
        long start = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            getName.invoke(teacher);
        }
        long end = System.currentTimeMillis();
        System.out.println("關閉安全檢查反射方式執行10億次消耗：" + (end - start) + "ms");
    }

}


class Teacher {

    private String name;

    public String getName() {
        return name;
    }

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

//輸出結果
普通方式執行10億次消耗：13ms
反射方式執行10億次消耗：20141ms
關閉安全檢查反射方式執行10億次消耗：8233ms

通過實驗可知，反射比直接執行相同的方法慢了很多，特別是當反射的操作被頻繁呼叫時效果更明顯，當然通過關閉安全檢查可以提高一些速度。所以，放射也不應該氾濫成災的，而是適度使用才能發揮最大作用。

Java註解與反射機制
2024-06-25
Java反射
Java利用spring註解做反射機制
2014-12-18
JavaSpring反射
Java反射與註解
2018-08-08
Java反射
從Java反射機制到Android註解框架
2016-06-13
Java反射Android框架
Java註解與反射學習筆記
2020-12-21
Java反射筆記
Java註解與反射的使用
2020-12-27
Java反射
Java之註解與反射
2021-07-21
Java反射
Java 反射機制詳解
2016-01-24
Java反射
java反射機制的學習心得
2021-02-20
Java反射
JAVA中的反射機制詳解
2007-09-26
Java反射
Typora+圖床詳解（小白都能學得會）
2020-12-15
圖床
Java的反射機制
2023-05-05
Java反射
Java反射機制
2024-09-22
Java反射
Java反射-註解
2019-01-19
Java反射
java註解，反射
2017-04-01
Java反射
Java反射機制實現與原理
2016-05-14
Java反射
Java 反射機制學習資料
2015-11-23
Java反射
Java 中的反射機制
2020-11-05
Java反射
註解與反射
2024-08-04
反射
菜鳥學Java（十四）——Java反射機制（一）
2013-11-06
Java反射
菜鳥學Java（十五）——Java反射機制（二）
2013-11-12
Java反射
Java核心反射機制
2021-07-08
Java反射
java利器——反射機制
2018-12-17
Java反射
Java反射機制(轉)
2017-12-01
Java反射
Java反射機制研究
2014-09-13
Java反射
Java 註解和反射
2020-11-20
Java反射
Java註解和反射
2024-05-01
Java反射
深入詳解Java反射機制與底層實現原理?
2023-01-04
Java反射
Java學習十七—反射機制：解鎖程式碼的無限可能
2024-11-03
Java反射
Java中的類反射機制
2020-04-04
Java反射
淺析java的反射機制
2017-07-26
Java反射
Java進階 | 泛型機制與反射原理
2021-06-23
Java泛型反射
Java - 反射機制與工廠設計模式
2023-02-21
Java反射設計模式
Java - 反射機制與單例設計模式
2023-02-21
Java反射單例設計模式
基於NACOS和JAVA反射機制動態更新JAVA靜態常量非@Value註解
2020-06-18
Java反射
Java反射機制那些事
2019-02-15
Java反射
Java反射機制簡答
2020-10-06
Java反射
說說 Java 反射機制
2016-09-04
Java反射