反射之中包含了一個「反」字，所以想要解釋反射就必須先從「正」開始解釋。
一般情況下，我們使用某個類時必定知道它是什麼類，是用來做什麼的。於是我們直接對這個類進行實例化，之後使用這個類對象進行操作。
Apple apple = new Apple(); //直接初始化，「正射」
apple.setPrice(4);
上面這樣子進行類對象的初始化，我們可以理解爲「正」。
而反射則是一開始並不知道我要初始化的類對象是什麼，自然也無法使用 new 關鍵字來創建對象了。
這時候，我們使用 JDK 提供的反射 API 進行反射調用：
Class clz = Class.forName("com.chenshuyi.reflect.Apple");
Method method = clz.getMethod("setPrice", int.class);
Constructor constructor = clz.getConstructor();
Object object = constructor.newInstance();
method.invoke(object, 4);
上面兩段代碼的執行結果，其實是完全一樣的。但是其思路完全不一樣，第一段代碼在未運行時就已經確定了要運行的類（Apple），而第二段代碼則是在運行時通過字符串值才得知要運行的類（com.chenshuyi.reflect.Apple）。
所以說什麼是反射？
反射就是在運行時才知道要操作的類是什麼，並且可以在運行時獲取類的完整構造，並調用對應的方法。
一個簡單的例子
上面提到的示例程序，其完整的程序代碼如下：
public class Apple {
private int price;
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public static void main(String[] args) throws Exception{
//正常的調用
Apple apple = new Apple();
apple.setPrice(5);
System.out.println("Apple Price:" + apple.getPrice());
//使用反射調用
Class clz = Class.forName("com.chenshuyi.api.Apple");
Method setPriceMethod = clz.getMethod("setPrice", int.class);
Constructor appleConstructor = clz.getConstructor();
Object appleObj = appleConstructor.newInstance();
setPriceMethod.invoke(appleObj, 14);
Method getPriceMethod = clz.getMethod("getPrice");
System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
}
}
從代碼中可以看到我們使用反射調用了 setPrice 方法，並傳遞了 14 的值。之後使用反射調用了 getPrice 方法，輸出其價格。上面的代碼整個的輸出結果是：
Apple Price:5
Apple Price:14
從這個簡單的例子可以看出，一般情況下我們使用反射獲取一個對象的步驟：
- 獲取類的 Class 對象實例
Class clz = Class.forName("com.zhenai.api.Apple");
- 根據 Class 對象實例獲取 Constructor 對象
Constructor appleConstructor = clz.getConstructor();
- 使用 Constructor 對象的 newInstance 方法獲取反射類對象
Object appleObj = appleConstructor.newInstance();
而如果要調用某一個方法，則需要經過下面的步驟：
- 獲取方法的 Method 對象
Method setPriceMethod = clz.getMethod("setPrice", int.class);
- 利用 invoke 方法調用方法
setPriceMethod.invoke(appleObj, 14);
到這裏，我們已經能夠掌握反射的基本使用。但如果要進一步掌握反射，還需要對反射的常用 API 有更深入的理解。
在 JDK 中，反射相關的 API 可以分爲下面幾個方面：獲取反射的 Class 對象、通過反射創建類對象、通過反射獲取類屬性方法及構造器。
反射常用API
獲取反射中的Class對象
在反射中，要獲取一個類或調用一個類的方法，我們首先需要獲取到該類的 Class 對象。
在 Java API 中，獲取 Class 類對象有三種方法：
第一種，使用 Class.forName 靜態方法。當你知道該類的全路徑名時，你可以使用該方法獲取 Class 類對象。
Class clz = Class.forName("java.lang.String");
第二種，使用 .class 方法。
這種方法只適合在編譯前就知道操作的 Class。
Class clz = String.class;
第三種，使用類對象的 getClass() 方法。
String str = new String("Hello");
Class clz = str.getClass();
通過反射創建類對象
通過反射創建類對象主要有兩種方式：通過 Class 對象的 newInstance() 方法、通過 Constructor 對象的 newInstance() 方法。
第一種：通過 Class 對象的 newInstance() 方法。
Class clz = Apple.class;
Apple apple = (Apple)clz.newInstance();
第二種：通過 Constructor 對象的 newInstance() 方法
Class clz = Apple.class;
Constructor constructor = clz.getConstructor();
Apple apple = (Apple)constructor.newInstance();
通過 Constructor 對象創建類對象可以選擇特定構造方法，而通過 Class 對象則只能使用默認的無參數構造方法。下面的代碼就調用了一個有參數的構造方法進行了類對象的初始化。
Class clz = Apple.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
Apple apple = (Apple)constructor.newInstance("紅富士", 15);
通過反射獲取類屬性、方法、構造器
我們通過 Class 對象的 getFields() 方法可以獲取 Class 類的屬性，但無法獲取私有屬性。
Class clz = Apple.class;
Field[] fields = clz.getFields();
for (Field field : fields) {
System.out.println(field.getName());
}
輸出結果是：
price
而如果使用 Class 對象的 getDeclaredFields() 方法則可以獲取包括私有屬性在內的所有屬性：
Class clz = Apple.class;
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName());
}
輸出結果是：
name
price
與獲取類屬性一樣，當我們去獲取類方法、類構造器時，如果要獲取私有方法或私有構造器，則必須使用有 declared 關鍵字的方法。
反射源碼解析
當我們懂得了如何使用反射後，今天我們就來看看 JDK 源碼中是如何實現反射的。或許大家平時沒有使用過反射，但是在開發 Web 項目的時候會遇到過下面的異常：
java.lang.NullPointerException
...
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:497)
可以看到異常堆棧指出了異常在 Method 的第 497 的 invoke 方法中，其實這裏指的 invoke 方法就是我們反射調用方法中的 invoke。
Method method = clz.getMethod("setPrice", int.class);
method.invoke(object, 4); //就是這裏的invoke方法
例如我們經常使用的 Spring 配置中，經常會有相關 Bean 的配置：
<bean class="com.chenshuyi.Apple">
</bean>
當我們在 XML 文件中配置了上面這段配置之後，Spring 便會在啓動的時候利用反射去加載對應的 Apple 類。而當 Apple 類不存在或發生啓發異常時，異常堆棧便會將異常指向調用的 invoke 方法。
從這裏可以看出，我們平常很多框架都使用了反射，而反射中最最終的就是 Method 類的 invoke 方法了。
下面我們來看看 JDK 的 invoke 方法到底做了些什麼。
進入 Method 的 invoke 方法我們可以看到，一開始是進行了一些權限的檢查，最後是調用了 MethodAccessor 類的 invoke 方法進行進一步處理，如下圖紅色方框所示。
那麼 MethodAccessor 又是什麼呢？
其實 MethodAccessor 是一個接口，定義了方法調用的具體操作，而它有三個具體的實現類：
- sun.reflect.DelegatingMethodAccessorImpl
- sun.reflect.MethodAccessorImpl
- sun.reflect.NativeMethodAccessorImpl
而要看 ma.invoke() 到底調用的是哪個類的 invoke 方法，則需要看看 MethodAccessor 對象返回的到底是哪個類對象，所以我們需要進入 acquireMethodAccessor() 方法中看看。
從 acquireMethodAccessor() 方法我們可以看到，代碼先判斷是否存在對應的 MethodAccessor 對象，如果存在那麼就複用之前的 MethodAccessor 對象，否則調用 ReflectionFactory 對象的 newMethodAccessor 方法生成一個 MethodAccessor 對象。
在 ReflectionFactory 類的 newMethodAccessor 方法裏，我們可以看到首先是生成了一個 NativeMethodAccessorImpl 對象，再這個對象作爲參數調用 DelegatingMethodAccessorImpl 類的構造方法。
這裏的實現是使用了代理模式，將 NativeMethodAccessorImpl 對象交給 DelegatingMethodAccessorImpl 對象代理。我們查看 DelegatingMethodAccessorImpl 類的構造方法可以知道，其實是將 NativeMethodAccessorImpl 對象賦值給 DelegatingMethodAccessorImpl 類的 delegate 屬性。
所以說ReflectionFactory 類的 newMethodAccessor 方法最終返回 DelegatingMethodAccessorImpl 類對象。所以我們在前面的 ma.invoke() 裏，其將會進入 DelegatingMethodAccessorImpl 類的 invoke 方法中。
進入 DelegatingMethodAccessorImpl 類的 invoke 方法後，這裏調用了 delegate 屬性的 invoke 方法，它又有兩個實現類，分別是：DelegatingMethodAccessorImpl 和 NativeMethodAccessorImpl。按照我們前面說到的，這裏的 delegate 其實是一個 NativeMethodAccessorImpl 對象，所以這裏會進入 NativeMethodAccessorImpl 的 invoke 方法。
而在 NativeMethodAccessorImpl 的 invoke 方法裏，其會判斷調用次數是否超過閥值（numInvocations）。如果超過該閥值，那麼就會生成另一個MethodAccessor 對象，並將原來 DelegatingMethodAccessorImpl 對象中的 delegate 屬性指向最新的 MethodAccessor 對象。
到這裏，其實我們可以知道 MethodAccessor 對象其實就是具體去生成反射類的入口。通過查看源碼上的註釋，我們可以瞭解到 MethodAccessor 對象的一些設計信息。
"Inflation" mechanism. Loading bytecodes to implement Method.invoke() and Constructor.newInstance() currently costs 3-4x more than an invocation via native code for the first invocation (though subsequent invocations have been benchmarked to be over 20x faster).Unfortunately this cost increases startup time for certain applications that use reflection intensively (but only once per class) to bootstrap themselves.
Inflation 機制。初次加載字節碼實現反射，使用 Method.invoke() 和 Constructor.newInstance() 加載花費的時間是使用原生代碼加載花費時間的 3 - 4 倍。這使得那些頻繁使用反射的應用需要花費更長的啓動時間。
To avoid this penalty we reuse the existing JVM entry points for the first few invocations of Methods and Constructors and then switch to the bytecode-based implementations. Package-private to be accessible to NativeMethodAccessorImpl and NativeConstructorAccessorImpl.
爲了避免這種痛苦的加載時間，我們在第一次加載的時候重用了 JVM 的入口，之後切換到字節碼實現的實現。
就像註釋裏說的，實際的 MethodAccessor 實現有兩個版本，一個是 Native 版本，一個是 Java 版本。
Native 版本一開始啓動快，但是隨着運行時間邊長，速度變慢。Java 版本一開始加載慢，但是隨着運行時間邊長，速度變快。正是因爲兩種存在這些問題，所以第一次加載的時候我們會發現使用的是 NativeMethodAccessorImpl 的實現，而當反射調用次數超過 15 次之後，則使用 MethodAccessorGenerator 生成的 MethodAccessorImpl 對象去實現反射。
Method 類的 invoke 方法整個流程可以表示成如下的時序圖：
講到這裏，我們瞭解了 Method 類的 invoke 方法的具體實現方式。知道了原來 invoke 方法內部有兩種實現方式，一種是 native 原生的實現方式，一種是 Java 實現方式，這兩種各有千秋。而爲了最大化性能優勢，JDK 源碼使用了代理的設計模式去實現最大化性能。