轉載
參考地址：https://www.zhihu.com/question/24304289
首先我們了解一下JVM，什么是JVM，Java的虛擬機，java之所以能跨平台就是因為這個東西，你可以理解成一個進程，程序，只不過他的作用是用來跑你的代碼的。上圖是java的內存模型，我們關注的點，一個方法區，一個棧，一個堆，初學的時候老師不深入的話只告訴你java的內存分為堆和棧，易懂點吧！
假如你寫了一段代碼：Object o=new Object();
運行了起來！
首先JVM會啟動，你的代碼會編譯成一個.class文件，然后被類加載器加載進jvm的內存中，你的類Object加載到方法區中，創建了Object類的class對象到堆中，注意這個不是new出來的對象，而是類的類型對象，每個類只有一個class對象，作為方法區類的數據結構的接口。jvm創建對象前，會先檢查類是否加載，尋找類對應的class對象，若加載好，則為你的對象分配內存，初始化也就是代碼:new Object()。
上面的流程就是你自己寫好的代碼扔給jvm去跑，跑完就over了，jvm關閉，你的程序也停止了。
為什么要講這個呢？因為要理解反射必須知道它在什么場景下使用。
題主想想上面的程序對象是自己new的，程序相當於寫死了給jvm去跑。假如一個服務器上突然遇到某個請求哦要用到某個類，哎呀但沒加載進jvm，是不是要停下來自己寫段代碼，new一下，哦啟動一下服務器，（腦殘）！
反射是什么呢？當我們的程序在運行時，需要動態的加載一些類這些類可能之前用不到所以不用加載到jvm，而是在運行時根據需要才加載，這樣的好處對於服務器來說不言而喻，舉個例子我們的項目底層有時是用mysql，有時用oracle，需要動態地根據實際情況加載驅動類，這個時候反射就有用了，假設 com.java.dbtest.myqlConnection，com.java.dbtest.oracleConnection這兩個類我們要用，這時候我們的程序就寫得比較動態化，通過Class tc = Class.forName("com.java.dbtest.TestConnection");通過類的全類名讓jvm在服務器中找到並加載這個類，而如果是oracle則傳入的參數就變成另一個了。這時候就可以看到反射的好處了，這個動態性就體現出java的特性了！舉多個例子，大家如果接觸過spring，會發現當你配置各種各樣的bean時，是以配置文件的形式配置的，你需要用到哪些bean就配哪些，spring容器就會根據你的需求去動態加載，你的程序就能健壯地運行。
什么是反射？
反射 (Reflection) 是 Java 的特征之一，它允許運行中的 Java 程序獲取自身的信息，並且可以操作類或對象的內部屬性。
Oracle 官方對反射的解釋是：
Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts, within security restrictions.
The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. It also allows programs to suppress default reflective access control.
反射的核心是 JVM 在運行時才動態加載類或調用方法/訪問屬性，它不需要事先（寫代碼的時候或編譯期）知道運行對象是誰。
Java 反射主要提供以下功能：
- 在運行時判斷任意一個對象所屬的類；
- 在運行時構造任意一個類的對象；
- 在運行時判斷任意一個類所具有的成員變量和方法（通過反射甚至可以調用private方法）；
- 在運行時調用任意一個對象的方法
重點：是運行時而不是編譯時
二、反射的主要用途
很多人都認為反射在實際的 Java 開發應用中並不廣泛，其實不然。當我們在使用 IDE(如 Eclipse，IDEA)時，當我們輸入一個對象或類並想調用它的屬性或方法時，一按點號，編譯器就會自動列出它的屬性或方法，這里就會用到反射。
反射最重要的用途就是開發各種通用框架。很多框架（比如 Spring）都是配置化的（比如通過 XML 文件配置 Bean），為了保證框架的通用性，它們可能需要根據配置文件加載不同的對象或類，調用不同的方法，這個時候就必須用到反射，運行時動態加載需要加載的對象。
舉一個例子，在運用 Struts 2 框架的開發中我們一般會在 struts.xml 里去配置 Action，比如：
|
1
2
3
4
5
6
|
<action name="login"
class="org.ScZyhSoft.test.action.SimpleLoginAction"
method="execute">
<result>/shop/shop-index.jsp</result>
<result name="error">login.jsp</result>
</action>
|
配置文件與 Action 建立了一種映射關系，當 View 層發出請求時，請求會被 StrutsPrepareAndExecuteFilter 攔截，然后 StrutsPrepareAndExecuteFilter 會去動態地創建 Action 實例。比如我們請求 login.action，那么 StrutsPrepareAndExecuteFilter就會去解析struts.xml文件，檢索action中name為login的Action，並根據class屬性創建SimpleLoginAction實例，並用invoke方法來調用execute方法，這個過程離不開反射。
對與框架開發人員來說，反射雖小但作用非常大，它是各種容器實現的核心。而對於一般的開發者來說，不深入框架開發則用反射用的就會少一點，不過了解一下框架的底層機制有助於豐富自己的編程思想，也是很有益的。
三、反射的基本運用
上面我們提到了反射可以用於判斷任意對象所屬的類，獲得 Class 對象，構造任意一個對象以及調用一個對象。這里我們介紹一下基本反射功能的使用和實現(反射相關的類一般都在 java.lang.relfect 包里)。
1、獲得 Class 對象
方法有三種：
(1) 使用 Class 類的 forName 靜態方法:
|
1
2
3
4
5
6
7
|
public static Class<?> forName(String className)
```
比如在 JDBC 開發中常用此方法加載數據庫驅動:
```java
Class.forName(driver);
|
(2)直接獲取某一個對象的 class，比如:
|
1
2
|
Class<?> klass =
int.class;
Class<?> classInt = Integer.TYPE;
|
(3)調用某個對象的 getClass() 方法，比如:
|
1
2
|
StringBuilder str =
new StringBuilder("123");
Class<?> klass = str.getClass();
|
2、判斷是否為某個類的實例
一般地，我們用 instanceof 關鍵字來判斷是否為某個類的實例。同時我們也可以借助反射中 Class 對象的 isInstance() 方法來判斷是否為某個類的實例，它是一個 native 方法：
|
1
|
public native boolean isInstance(Object obj);
|
3、創建實例
通過反射來生成對象主要有兩種方式。
- 使用Class對象的newInstance()方法來創建Class對象對應類的實例。
|
1
2
|
Class<?> c = String.class;
Object str = c.newInstance();
|
- 先通過Class對象獲取指定的Constructor對象，再調用Constructor對象的newInstance()方法來創建實例。這種方法可以用指定的構造器構造類的實例。
|
1
2
3
4
5
6
7
|
//獲取String所對應的Class對象
Class<?> c = String.class;
//獲取String類帶一個String參數的構造器
Constructor constructor = c.getConstructor(String.class);
//根據構造器創建實例
Object obj = constructor.newInstance(
"23333");
System.out.println(obj);
|
4、獲取方法
獲取某個Class對象的方法集合，主要有以下幾個方法：
getDeclaredMethods方法返回類或接口聲明的所有方法，包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法。
|
1
|
public Method[] getDeclaredMethods() throws SecurityException
|
getMethods方法返回某個類的所有公用（public）方法，包括其繼承類的公用方法。
|
1
|
public Method[] getMethods() throws SecurityException
|
getMethod方法返回一個特定的方法，其中第一個參數為方法名稱，后面的參數為方法的參數對應Class的對象。
|
1
|
public Method getMethod(String name, Class<?>... parameterTypes)
|
只是這樣描述的話可能難以理解，我們用例子來理解這三個方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
package org.ScZyhSoft.common;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test1 {
public static void test() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> c = methodClass.class;
Object object = c.newInstance();
Method[] methods = c.getMethods();
Method[] declaredMethods = c.getDeclaredMethods();
//獲取methodClass類的add方法
Method method = c.getMethod(
"add", int.class, int.class);
//getMethods()方法獲取的所有方法
System.out.println(
"getMethods獲取的方法：");
for(Method m:methods)
System.out.println(m);
//getDeclaredMethods()方法獲取的所有方法
System.out.println(
"getDeclaredMethods獲取的方法：");
for(Method m:declaredMethods)
System.out.println(m);
}
}
class methodClass {
public final int fuck = 3;
public int add(int a,int b) {
return a+b;
}
public int sub(int a,int b) {
return a+b;
}
}
|
程序運行的結果如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
getMethods獲取的方法：
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
getDeclaredMethods獲取的方法：
public int org.ScZyhSoft.common.methodClass.add(int,int)
public int org.ScZyhSoft.common.methodClass.sub(int,int)
|
可以看到，通過 getMethods() 獲取的方法可以獲取到父類的方法,比如 java.lang.Object 下定義的各個方法。
5、獲取構造器信息
獲取類構造器的用法與上述獲取方法的用法類似。主要是通過Class類的getConstructor方法得到Constructor類的一個實例，而Constructor類有一個newInstance方法可以創建一個對象實例:
|
1
|
public T newInstance(Object ... initargs)
|
此方法可以根據傳入的參數來調用對應的Constructor創建對象實例。
6、獲取類的成員變量（字段）信息
主要是這幾個方法，在此不再贅述：
getFiled：訪問公有的成員變量getDeclaredField：所有已聲明的成員變量，但不能得到其父類的成員變量
getFileds 和 getDeclaredFields 方法用法同上（參照 Method）。
7、調用方法
當我們從類中獲取了一個方法后，我們就可以用 invoke() 方法來調用這個方法。invoke 方法的原型為:
|
1
2
3
|
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
|
下面是一個實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class test1 {
public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> klass = methodClass.class;
//創建methodClass的實例
Object obj = klass.newInstance();
//獲取methodClass類的add方法
Method method = klass.getMethod(
"add",int.class,int.class);
//調用method對應的方法 => add(1,4)
Object result = method.invoke(obj,
1,4);
System.out.println(result);
}
}
class methodClass {
public final int fuck = 3;
public int add(int a,int b) {
return a+b;
}
public int sub(int a,int b) {
return a+b;
}
}
|
關於 invoke 方法的詳解，后面我會專門寫一篇文章來深入解析 invoke 的過程。
8、利用反射創建數組
數組在Java里是比較特殊的一種類型，它可以賦值給一個Object Reference。下面我們看一看利用反射創建數組的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public static void testArray() throws ClassNotFoundException {
Class<?> cls = Class.forName(
"java.lang.String");
Object array = Array.newInstance(cls,
25);
//往數組里添加內容
Array.set(array,
0,"hello");
Array.set(array,
1,"Java");
Array.set(array,
2,"fuck");
Array.set(array,
3,"Scala");
Array.set(array,
4,"Clojure");
//獲取某一項的內容
System.out.println(Array.get(array,
3));
}
|
其中的Array類為java.lang.reflect.Array類。我們通過Array.newInstance()創建數組對象，它的原型是:
|
1
2
3
4
|
public static Object newInstance(Class<?> componentType, int length)
throws NegativeArraySizeException {
return newArray(componentType, length);
}
|
而 newArray 方法是一個 native 方法，它在 HotSpot JVM 里的具體實現我們后邊再研究，這里先把源碼貼出來：
|
1
2
|
private static native Object newArray(Class<?> componentType, int length)
throws NegativeArraySizeException;
|
源碼目錄：openjdk\hotspot\src\share\vm\runtime\reflection.cpp
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
if (element_mirror == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
if (length < 0) {
THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
}
if (java_lang_Class::is_primitive(element_mirror)) {
Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
}
else {
Klass* k = java_lang_Class::as_Klass(element_mirror);
if (k->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
return oopFactory::new_objArray(k, length, THREAD);
}
}
|
另外，Array 類的 set 和 get 方法都為 native 方法，在 HotSpot JVM 里分別對應 Reflection::array_set 和 Reflection::array_get 方法，這里就不詳細解析了。
四、反射的一些注意事項
由於反射會額外消耗一定的系統資源，因此如果不需要動態地創建一個對象，那么就不需要用反射。
另外，反射調用方法時可以忽略權限檢查，因此可能會破壞封裝性而導致安全問題。