Java 反射 Reflection

1. 瞭解 Java 中的反射

1.1 什麼是 Java 的反射

Java 反射是可以讓我們在運行時獲取類的函數、屬性、父類、接口等 Class 內部信息的機制。通過反射還可以讓我們在運行期實例化對象，調用方法，通過調用 get/set 方法獲取變量的值，即使方法或屬性是私有的的也可以通過反射的形式調用，這種“看透 class”的能力被稱爲內省，這種能力在框架開發中尤爲重要。 有些情況下，我們要使用的類在運行時纔會確定，這個時候我們不能在編譯期就使用它，因此只能通過反射的形式來使用在運行時才存在的類(該類符合某種特定的規範，例如 JDBC)，這是反射用得比較多的場景。
還有一個比較常見的場景就是編譯時我們對於類的內部信息不可知，必須得到運行時才能獲取類的具體信息。比如 ORM 框架，在運行時才能夠獲取類中的各個屬性，然後通過反射的形式獲取其屬性名和值，存入數據庫。這也是反射比較經典應用場景之一。

1.2 Class 類

那麼既然反射是操作 Class 信息的，Class 又是什麼呢?

當我們編寫完一個 Java 項目之後，所有的 Java 文件都會被編譯成一個.class 文件，這些 Class 對象承載了這個類型的父類、接口、構造函數、方法、屬性等原始信息，這些 class 文件在程序運行時會被 ClassLoader 加載到虛擬機中。當一個類被加載以後，Java 虛擬機就會在內存中自動產生一個 Class 對象。我們通過 new 的形式創建對象實際上就是通過這些 Class 來創建，只是這個過程對於我們是不透明的而已。
下面的章節中我們會爲大家演示反射的一些常用 api，從代碼的角度理解反射。

2. 反射 Class 以及構造對象

2.1 獲取 Class 對象

在你想檢查一個類的信息之前，你首先需要獲取類的 Class 對象。Java 中的所有類型包括基本類型，即使是數組都有與之關聯的 Class 類的對象。如果你在編譯期知道一個類的名字的話，那麼你可以使用如下的方式獲取一個類的 Class 對象。

Class<?> myObjectClass = MyObject.class;

如果你已經得到了某個對象，但是你想獲取這個對象的 Class 對象，那麼你可以通過下面的方法得到:

Student me = new Student("mr.simple");
Class<?> clazz = me.getClass();

如果你在編譯期獲取不到目標類型，但是你知道它的完整類路徑，那麼你可以通過如下的形式來獲取 Class 對象:

Class<?> myObjectClass = Class.forName("com.simple.User");

在使用 Class.forName()方法時，你必須提供一個類的全名，這個全名包括類所在的包的名字。例如 User 類位於 com.simple 包，那麼他的完整類路徑就是 com.simple.User。
如果在調用 Class.forName()方法時，沒有在編譯路徑下(classpath)找到對應的類，那麼將會拋出 ClassNotFoundException。

接口說明

// 加載指定的 Class 對象，參數 1 爲要加載的類的完整路徑，例如"com.simple.Student". ( 常用方式 )
public static Class<?> forName (String className)

// 加載指定的 Class 對象，參數 1 爲要加載的類的完整路徑，例如"com.simple.Student";
// 參數 2 爲是否要初始化該 Class 對象，參數 3 爲指定加載該類的 ClassLoader.
public static Class<?> forName (String className, boolean shouldInitialize, ClassLoader classLoader)

2.2 通過 Class 對象構造目標類型的對象

一旦你拿到 Class 對象之後，你就可以爲所欲爲了！當你善用它的時候它就是神兵利器，當你心懷鬼胎之時它就會變成惡魔。但獲取 Class 對象只是第一步，我們需要在執行那些強大的行爲之前通過 Class 對象構造出該類型的對象，然後才能通過該對象釋放它的能量。 我們知道，在 java 中要構造對象，必須通過該類的構造函數，那麼其實反射也是一樣一樣的。但是它們確實有區別的，通過反射構造對象，我們首先要獲取類的 Constructor(構造器)對象，然後通過 Constructor 來創建目標類的對象。還是直接上代碼的。

    private static void classForName() {
        try {
            // 獲取 Class 對象
            Class<?> clz = Class.forName("org.java.advance.reflect.Student");
            // 通過 Class 對象獲取 Constructor，Student 的構造函數有一個字符串參數
            // 因此這裏需要傳遞參數的類型 ( Student 類見後面的代碼 )
            Constructor<?> constructor = clz.getConstructor(String.class);
            // 通過 Constructor 來創建 Student 對象
            Object obj = constructor.newInstance("mr.simple");
            System.out.println(" obj :  " + obj.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通過上述代碼，我們就可以在運行時通過完整的類名來構建對象。

獲取構造函數接口

// 獲取一個公有的構造函數，參數爲可變參數，如果構造函數有參數，那麼需要將參數的類型傳遞給 getConstructor 方法
public Constructor<T> getConstructor (Class...<?> parameterTypes)
// 獲取目標類所有的公有構造函數
public Constructor[]<?> getConstructors ()

注意，當你通過反射獲取到 Constructor、Method、Field 後，在反射調用之前將此對象的 accessible 標誌設置爲 true，以此來提升反射速度。值爲 true 則指示反射的對象在使用時應該取消 Java 語言訪問檢查。值爲 false 則指示反射的對象應該實施 Java 語言訪問檢查。例如 :

   Constructor<?> constructor = clz.getConstructor(String.class);
   // 設置 Constructor 的 Accessible
   constructor.setAccessible(true);

   // 設置 Methohd 的 Accessible
   Method learnMethod = Student.class.getMethod("learn"， String.class);
   learnMethod.setAccessible(true);

由於後面還會用到 Student 以及相關的類，我們在這裏就先給出它們的代碼吧。
Person.java

public class Person {
    String mName;

    public Person(String aName) {
        mName = aName;
    }

    private void sayHello(String friendName) {
        System.out.println(mName + " say hello to " + friendName);
    }

    protected void showMyName() {
        System.out.println("My name is " + mName);
    }

    public void breathe() {
        System.out.println(" take breathe ");
    }
}

Student.java

public class Student extends Person implements Examination {
    // 年級
    int mGrade;

    public Student(String aName) {
        super(aName);
    }

    public Student(int grade, String aName) {
        super(aName);
        mGrade = grade;
    }

    private void learn(String course) {
        System.out.println(mName + " learn " + course);
    }

    public void takeAnExamination() {
        System.out.println(" takeAnExamination ");
    }

    public String toString() {
        return " Student :  " + mName;
    }

Breathe.java

// 呼吸接口
public interface Breathe {
    public void breathe();
}

Examination.java

// 考試接口
public interface Examination {
    public void takeAnExamination();
}

3 反射獲取類中函數

3.1 獲取當前類中定義的方法

要獲取當前類中定義的所有方法可以通過 Class 中的 getDeclaredMethods 函數，它會獲取到當前類中的 public、default、protected、private 的所有方法。而 getDeclaredMethod(String name, Class...<?> parameterTypes)則是獲取某個指定的方法。代碼示例如下 :

 private static void showDeclaredMethods() {
      Student student = new Student("mr.simple");
        Method[] methods = student.getClass().getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("declared method name : " + method.getName());
        }

        try {
            Method learnMethod = student.getClass().getDeclaredMethod("learn", String.class);
            // 獲取方法的參數類型列表
            Class<?>[] paramClasses = learnMethod.getParameterTypes() ;
            for (Class<?> class1 : paramClasses) {
                System.out.println("learn 方法的參數類型 : " + class1.getName());
            }
            // 是否是 private 函數，屬性是否是 private 也可以使用這種方式判斷
            System.out.println(learnMethod.getName() + " is private "
                    + Modifier.isPrivate(learnMethod.getModifiers()));
            learnMethod.invoke(student, "java ---> ");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

3.2 獲取當前類、父類中定義的公有方法

要獲取當前類以及父類中的所有 public 方法可以通過 Class 中的 getMethods 函數，而 getMethod 則是獲取某個指定的方法。代碼示例如下 :

    private static void showMethods() {
        Student student = new Student("mr.simple");
        // 獲取所有方法
        Method[] methods = student.getClass().getMethods();
        for (Method method : methods) {
            System.out.println("method name : " + method.getName());
        }

        try {
            // 通過 getMethod 只能獲取公有方法，如果獲取私有方法則會拋出異常，比如這裏就會拋異常
            Method learnMethod = student.getClass().getMethod("learn", String.class);
            // 是否是 private 函數，屬性是否是 private 也可以使用這種方式判斷
            System.out.println(learnMethod.getName() + " is private " + Modifier.isPrivate(learnMethod.getModifiers()));
            // 調用 learn 函數
            learnMethod.invoke(student, "java");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

接口說明

// 獲取 Class 對象中指定函數名和參數的函數，參數一爲函數名，參數 2 爲參數類型列表
public Method getDeclaredMethod (String name, Class...<?> parameterTypes)

// 獲取該 Class 對象中的所有函數( 不包含從父類繼承的函數 )
public Method[] getDeclaredMethods ()

// 獲取指定的 Class 對象中的**公有**函數，參數一爲函數名，參數 2 爲參數類型列表
public Method getMethod (String name, Class...<?> parameterTypes)

// 獲取該 Class 對象中的所有**公有**函數 ( 包含從父類和接口類集成下來的函數 )
public Method[] getMethods ()

這裏需要注意的是 getDeclaredMethod 和 getDeclaredMethods 包含 private、protected、default、public 的函數，並且通過這兩個函數獲取到的只是在自身中定義的函數，從父類中集成的函數不能夠獲取到。而 getMethod 和 getMethods 只包含 public 函數，父類中的公有函數也能夠獲取到。

4 反射獲取類中的屬性

獲取屬性和章節 3 中獲取方法是非常相似的，只是從 getMethod 函數換成了 getField，從 getDeclaredMethod 換成了 getDeclaredField 罷了。

4.1 獲取當前類中定義的屬性

要獲取當前類中定義的所有屬性可以通過 Class 中的 getDeclaredFields 函數，它會獲取到當前類中的 public、default、protected、private 的所有屬性。而 getDeclaredField 則是獲取某個指定的屬性。代碼示例如下 :

    private static void showDeclaredFields() {
        Student student = new Student("mr.simple");
        // 獲取當前類和父類的所有公有屬性
        Field[] publicFields = student.getClass().getDeclaredFields();
        for (Field field : publicFields) {
            System.out.println("declared field name : " + field.getName());
        }

        try {
            // 獲取當前類和父類的某個公有屬性
            Field gradeField = student.getClass().getDeclaredField("mGrade");
            // 獲取屬性值
            System.out.println(" my grade is : " + gradeField.getInt(student));
            // 設置屬性值
            gradeField.set(student, 10);
            System.out.println(" my grade is : " + gradeField.getInt(student));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2 獲取當前類、父類中定義的公有屬性

要獲取當前類以及父類中的所有 public 屬性可以通過 Class 中的 getFields 函數，而 getField 則是獲取某個指定的屬性。代碼示例如下 :

    private static void showFields() {
        Student student = new Student("mr.simple");
        // 獲取當前類和父類的所有公有屬性
        Field[] publicFields = student.getClass().getFields();
        for (Field field : publicFields) {
            System.out.println("field name : " + field.getName());
        }

        try {
            // 獲取當前類和父類的某個公有屬性
            Field ageField = student.getClass().getField("mAge");
            System.out.println(" age is : " + ageField.getInt(student));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

接口說明

// 獲取 Class 對象中指定屬性名的屬性，參數一爲屬性名
public Method getDeclaredField (String name)

// 獲取該 Class 對象中的所有屬性( 不包含從父類繼承的屬性 )
public Method[] getDeclaredFields ()

// 獲取指定的 Class 對象中的**公有**屬性，參數一爲屬性名
public Method getField (String name)

// 獲取該 Class 對象中的所有**公有**屬性 ( 包含從父類和接口類集成下來的公有屬性 )
public Method[] getFields ()

這裏需要注意的是 getDeclaredField 和 getDeclaredFields 包含 private、protected、default、public 的屬性，並且通過這兩個函數獲取到的只是在自身中定義的屬性，從父類中集成的屬性不能夠獲取到。而 getField 和 getFields 只包含 public 屬性，父類中的公有屬性也能夠獲取到。

5 反射獲取父類與接口

5.1 獲取父類

獲取 Class 對象的父類。

    Student student = new Student("mr.simple");
    Class<?> superClass = student.getClass().getSuperclass();
    while (superClass != null) {
        System.out.println("Student's super class is : " + superClass.getName());
        // 再獲取父類的上一層父類，直到最後的 Object 類，Object 的父類爲 null
        superClass = superClass.getSuperclass();
    }

5.2 獲取接口

獲取 Class 對象中實現的接口。

    private static void showInterfaces() {
        Student student = new Student("mr.simple");
        Class<?>[] interfaceses = student.getClass().getInterfaces();
        for (Class<?> class1 : interfaceses) {
            System.out.println("Student's interface is : " + class1.getName());
        }
    }

6 獲取註解信息

在框架開發中，註解加反射的組合使用是最爲常見形式的。關於註解方面的知識請參考 Java 註解 Annotation，定義註解時我們會通過@Target 指定該註解能夠作用的類型，看如下示例:

    @Target({
            ElementType.METHOD, ElementType.FIELD, ElementType.TYPE
    })
    @Retention(RetentionPolicy.RUNTIME)
    static @interface Test {

    }

上述註解的@target 表示該註解只能用在函數上，還有 Type、Field、PARAMETER 等類型，可以參考上述給出的參考資料。通過反射 api 我們也能夠獲取一個 Class 對象獲取類型、屬性、函數等相關的對象，通過這些對象的 getAnnotation 接口獲取到對應的註解信息。 首先我們需要在目標對象上添加上註解，例如 :

@Test(tag = "Student class Test Annoatation")
public class Student extends Person implements Examination {
    // 年級
    @Test(tag = "mGrade Test Annotation ")
    int mGrade;

    // ......
}

然後通過相關的註解函數得到註解信息，如下所示 :

    private static void getAnnotationInfos() {
        Student student = new Student("mr.simple");
        Test classTest = student.getClass().getAnnotation(Test.class);
        System.out.println("class Annotatation tag = " + classTest.tag());

        Field field = null;
        try {
            field = student.getClass().getDeclaredField("mGrade");
            Test testAnnotation = field.getAnnotation(Test.class);
            System.out.println("屬性的 Test 註解 tag : " + testAnnotation.tag());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

輸出結果爲 : >

class Annotatation tag = Student class Test Annoatation
屬性的 Test 註解 tag : mGrade Test Annotation

接口說明

// 獲取指定類型的註解
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) ;
// 獲取 Class 對象中的所有註解
public Annotation[] getAnnotations() ;

雜談

反射作爲 Java 語言的重要特性，在開發中有着極爲重要的作用。很多開發框架都是基於反射來實現對目標對象的操作，而反射配合註解更是設計開發框架的主流選擇，例如 ActiveAndroid，因此深入瞭解反射的作用以及使用對於日後開發和學習必定大有益處。