前言

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個注解是負責注解其他注解的(即元注解)，元注解提供對其他注解的型別說明，

自定義注解

使用@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反射機制提供的功能

1. 在運行時判斷任意一個物件所屬的類
2. 在運行時構造任意一個類的物件
3. 在運行時判斷任意一個類具有的成員變數和方法
4. 在運行時獲取泛型資訊
5. 在運行時呼叫任意一個物件的成員變數和方法
6. 在運行時獲取注解
7. 生成動態代理
8. …

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物件的方法

1. 如果知道具體的類，可通過類的class屬性獲取，這種方法最安全可靠并且性能最高，Class clz = User.class;
2. 通過類的實體的getClass()方法獲取，Class clz = user.getClass();
3. 如果知道一個類的全限定類名，并且在類路徑下，可通過Class.forName()方法獲取，但是可能會拋出ClassNotFoundException，Class clz = Class.forName("com.nobody.User");
4. 內置的基本資料型別可以直接通過類名.Type獲取，Class<Integer> clz = Integer.TYPE;
5. 通過類加載器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

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