本節所有目錄如下：
- 什麼是JAVA的反射機制
- JDK中提供的Reflection API
- JAVA反射機制提供了什麼功能
- 獲取類的Class對象
- 獲取類的Fields
- 獲取類的Method
- 獲取類的Constructor
- 新建類的實例
Class<T>的函數newInstance
通過Constructor對象的方法newInstance
- 調用類的函數
調用private函數 - 設置/獲取類的屬性值
private屬性 - 動態創建代理類
動態代理源碼分析 - JAVA反射Class<T>類型源代碼分析
- JAVA反射原理分析
Class文件結構
JVM加載類對象，對反射的支持 - JAVA反射的應用
一、什麼是JAVA的反射機制
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。
要想解剖一個類,必須先要獲取到該類的字節碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個字節碼文件對應的Class類型的對象.
二、JDK中提供的Reflection API
Java反射相關的API在包java.lang.reflect中，JDK 1.6.0的reflect包如下圖：
| Member接口 | 該接口可以獲取有關類成員（域或者方法）後者構造函數的信息。 |
| AccessibleObject類 | 該類是域(field)對象、方法(method)對象、構造函數(constructor)對象的基礎類。它提供了將反射的對象標記爲在使用時取消默認 Java 語言訪問控制檢查的能力。 |
| Array類 | 該類提供動態地生成和訪問JAVA數組的方法。 |
| Constructor類 | 提供一個類的構造函數的信息以及訪問類的構造函數的接口。 |
| Field類 | 提供一個類的域的信息以及訪問類的域的接口。 |
| Method類 | 提供一個類的方法的信息以及訪問類的方法的接口。 |
| Modifier類 | 提供了 static 方法和常量，對類和成員訪問修飾符進行解碼。 |
| Proxy類 | 提供動態地生成代理類和類實例的靜態方法。 |
三、JAVA反射機制提供了什麼功能
Java反射機制提供如下功能：
在運行時判斷任意一個對象所屬的類
在運行時構造任意一個類的對象
在運行時判段任意一個類所具有的成員變量和方法
在運行時調用任一個對象的方法
在運行時創建新類對象
在使用Java的反射功能時，基本首先都要獲取類的Class對象，再通過Class對象獲取其他的對象。
這裏首先定義用於測試的類:
- class Type{
- public int pubIntField;
- public String pubStringField;
- private int prvIntField;
- public Type(){
- Log("Default Constructor");
- }
- Type(int arg1, String arg2){
- pubIntField = arg1;
- pubStringField = arg2;
- Log("Constructor with parameters");
- }
- public void setIntField(int val) {
- this.prvIntField = val;
- }
- public int getIntField() {
- return prvIntField;
- }
- private void Log(String msg){
- System.out.println("Type:" + msg);
- }
- }
- class ExtendType extends Type{
- public int pubIntExtendField;
- public String pubStringExtendField;
- private int prvIntExtendField;
- public ExtendType(){
- Log("Default Constructor");
- }
- ExtendType(int arg1, String arg2){
- pubIntExtendField = arg1;
- pubStringExtendField = arg2;
- Log("Constructor with parameters");
- }
- public void setIntExtendField(int field7) {
- this.prvIntExtendField = field7;
- }
- public int getIntExtendField() {
- return prvIntExtendField;
- }
- private void Log(String msg){
- System.out.println("ExtendType:" + msg);
- }
- }
1、獲取類的Class對象
Class 類的實例表示正在運行的 Java 應用程序中的類和接口。獲取類的Class對象有多種方式：
| 調用getClass | Boolean var1 = true; Class<?> classType2 = var1.getClass(); System.out.println(classType2); 輸出：class java.lang.Boolean |
| 運用.class 語法 | Class<?> classType4 = Boolean.class; System.out.println(classType4); 輸出：class java.lang.Boolean |
| 運用static method Class.forName() | Class<?> classType5 = Class.forName("java.lang.Boolean"); System.out.println(classType5); 輸出：class java.lang.Boolean |
運用primitive wrapper classes的TYPE 語法 這裏返回的是原生類型，和Boolean.class返回的不同 | Class<?> classType3 = Boolean.TYPE; System.out.println(classType3); 輸出：boolean |
2、獲取類的Fields
可以通過反射機制得到某個類的某個屬性，然後改變對應於這個類的某個實例的該屬性值。JAVA 的Class<T>類提供了幾個方法獲取類的屬性。
| public FieldgetField(String name) | 返回一個 Field 對象，它反映此 Class 對象所表示的類或接口的指定公共成員字段 |
| public Field[] getFields() | 返回一個包含某些 Field 對象的數組，這些對象反映此 Class 對象所表示的類或接口的所有可訪問公共字段 |
| public FieldgetDeclaredField(Stringname) | 返回一個 Field 對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明字段 |
| public Field[] getDeclaredFields() | 返回 Field 對象的一個數組，這些對象反映此 Class 對象所表示的類或接口所聲明的所有字段 |
- Class<?> classType = ExtendType.class;
- // 使用getFields獲取屬性
- Field[] fields = classType.getFields();
- for (Field f : fields)
- {
- System.out.println(f);
- }
- System.out.println();
- // 使用getDeclaredFields獲取屬性
- fields = classType.getDeclaredFields();
- for (Field f : fields)
- {
- System.out.println(f);
- }
輸出：
public int com.quincy.ExtendType.pubIntExtendField
public java.lang.String com.quincy.ExtendType.pubStringExtendField
public int com.quincy.Type.pubIntField
public java.lang.String com.quincy.Type.pubStringField
public int com.quincy.ExtendType.pubIntExtendField
public java.lang.String com.quincy.ExtendType.pubStringExtendField
private int com.quincy.ExtendType.prvIntExtendField
可見getFields和getDeclaredFields區別：
getFields返回的是申明爲public的屬性，包括父類中定義，
getDeclaredFields返回的是指定類定義的所有定義的屬性，不包括父類的。
3、獲取類的Method
通過反射機制得到某個類的某個方法，然後調用對應於這個類的某個實例的該方法
Class<T>類提供了幾個方法獲取類的方法。
| public MethodgetMethod(String name,Class<?>... parameterTypes) | 返回一個 Method 對象，它反映此 Class 對象所表示的類或接口的指定公共成員方法 |
| public Method[] getMethods() | 返回一個包含某些 Method 對象的數組，這些對象反映此 Class 對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共 member 方法 |
public MethodgetDeclaredMethod(Stringname,Class<?>... parameterTypes) | 返回一個 Method 對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法 |
| public Method[] getDeclaredMethods() | 返回 Method 對象的一個數組，這些對象反映此 Class 對象表示的類或接口聲明的所有方法，包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法 |
- // 使用getMethods獲取函數
- Class<?> classType = ExtendType.class;
- Method[] methods = classType.getMethods();
- for (Method m : methods)
- {
- System.out.println(m);
- }
- System.out.println();
- // 使用getDeclaredMethods獲取函數
- methods = classType.getDeclaredMethods();
- for (Method m : methods)
- {
- System.out.println(m);
- }
輸出：
public void com.quincy.ExtendType.setIntExtendField(int)
public int com.quincy.ExtendType.getIntExtendField()
public void com.quincy.Type.setIntField(int)
public int com.quincy.Type.getIntField()
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
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 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()
private void com.quincy.ExtendType.Log(java.lang.String)
public void com.quincy.ExtendType.setIntExtendField(int)
public int com.quincy.ExtendType.getIntExtendField()
4、獲取類的Constructor
通過反射機制得到某個類的構造器，然後調用該構造器創建該類的一個實例
Class<T>類提供了幾個方法獲取類的構造器。
| public Constructor<T> getConstructor(Class<?>... parameterTypes) | 返回一個 Constructor 對象，它反映此 Class 對象所表示的類的指定公共構造方法 |
| public Constructor<?>[] getConstructors() | 返回一個包含某些 Constructor 對象的數組，這些對象反映此 Class 對象所表示的類的所有公共構造方法 |
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) | 返回一個 Constructor 對象，該對象反映此 Class 對象所表示的類或接口的指定構造方法 |
public Constructor<?>[] getDeclaredConstructors() | 返回 Constructor 對象的一個數組，這些對象反映此 Class 對象表示的類聲明的所有構造方法。它們是公共、保護、默認（包）訪問和私有構造方法 |
- // 使用getConstructors獲取構造器
- Constructor<?>[] constructors = classType.getConstructors();
- for (Constructor<?> m : constructors)
- {
- System.out.println(m);
- }
- System.out.println();
- // 使用getDeclaredConstructors獲取構造器
- constructors = classType.getDeclaredConstructors();
- for (Constructor<?> m : constructors)
- {
- System.out.println(m);
- }
- 輸出：
- public com.quincy.ExtendType()
- public com.quincy.ExtendType()
- com.quincy.ExtendType(int,java.lang.String)
5、新建類的實例
通過反射機制創建新類的實例，有幾種方法可以創建
| 調用無自變量ctor | 1、調用類的Class對象的newInstance方法，該方法會調用對象的默認構造器，如果沒有默認構造器，會調用失敗. Class<?> classType = ExtendType.class; Object inst = classType.newInstance(); System.out.println(inst); 輸出： Type:Default Constructor ExtendType:Default Constructor
2、調用默認Constructor對象的newInstance方法 Class<?> classType = ExtendType.class; Constructor<?> constructor1 = classType.getConstructor(); Object inst = constructor1.newInstance(); System.out.println(inst); 輸出： Type:Default Constructor ExtendType:Default Constructor com.quincy.ExtendType@1006d75 |
| 調用帶參數ctor | 3、調用帶參數Constructor對象的newInstance方法 Constructor<?> constructor2 = classType.getDeclaredConstructor(int.class, String.class); Object inst = constructor2.newInstance(1, "123"); System.out.println(inst); 輸出： Type:Default Constructor ExtendType:Constructor with parameters com.quincy.ExtendType@15e83f9 |
6、調用類的函數
通過反射獲取類Method對象，調用Field的Invoke方法調用函數。
- Class<?> classType = ExtendType.class;
- Object inst = classType.newInstance();
- Method logMethod = classType.<strong>getDeclaredMethod</strong>("Log", String.class);
- logMethod.invoke(inst, "test");
- 輸出：
- Type:Default Constructor
- ExtendType:Default Constructor
- <font color="#ff0000">Class com.quincy.ClassT can not access a member of class com.quincy.ExtendType with modifiers "private"</font>
- <font color="#ff0000">上面失敗是由於沒有權限調用private函數，這裏需要設置Accessible爲true;</font>
- Class<?> classType = ExtendType.class;
- Object inst = classType.newInstance();
- Method logMethod = classType.getDeclaredMethod("Log", String.class);
- <font color="#ff0000">logMethod.setAccessible(true);</font>
- logMethod.invoke(inst, "test");
7、設置/獲取類的屬性值
通過反射獲取類的Field對象，調用Field方法設置或獲取值
- Class<?> classType = ExtendType.class;
- Object inst = classType.newInstance();
- Field intField = classType.getField("pubIntExtendField");
- intField.<strong>setInt</strong>(inst, 100);
- int value = intField.<strong>getInt</strong>(inst);
四、動態創建代理類
代理模式：代理模式的作用=爲其他對象提供一種代理以控制對這個對象的訪問。
代理模式的角色：
抽象角色：聲明真實對象和代理對象的共同接口
代理角色：代理角色內部包含有真實對象的引用，從而可以操作真實對象。
真實角色：代理角色所代表的真實對象，是我們最終要引用的對象。
動態代理：
| java.lang.reflect.Proxy | Proxy 提供用於創建動態代理類和實例的靜態方法，它還是由這些方法創建的所有動態代理類的超類 |
| InvocationHandler | 是代理實例的調用處理程序 實現的接口，每個代理實例都具有一個關聯的調用處理程序。對代理實例調用方法時，將對方法調用進行編碼並將其指派到它的調用處理程序的 invoke 方法。 |
動態Proxy是這樣的一種類:
它是在運行生成的類，在生成時你必須提供一組Interface給它，然後該class就宣稱它實現了這些interface。你可以把該class的實例當作這些interface中的任何一個來用。當然，這個Dynamic Proxy其實就是一個Proxy，它不會替你作實質性的工作，在生成它的實例時你必須提供一個handler，由它接管實際的工作。
在使用動態代理類時，我們必須實現InvocationHandler接口
步驟：
1、定義抽象角色
public interface Subject {
public void Request();
}
2、定義真實角色
public class RealSubject implements Subject {
@Override
public void Request() {
// TODO Auto-generated method stub
System.out.println("RealSubject");
}
}
3、定義代理角色
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject(Object obj){
this.sub = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("Method:"+ method + ",Args:" + args);
method.invoke(sub, args);
return null;
}
}
4、通過Proxy.newProxyInstance構建代理對象
RealSubject realSub = new RealSubject();
InvocationHandler handler = new DynamicSubject(realSub);
Class<?> classType = handler.getClass();
Subject sub = (Subject)Proxy.newProxyInstance(classType.getClassLoader(),
realSub.getClass().getInterfaces(), handler);
System.out.println(sub.getClass());
5、通過調用代理對象的方法去調用真實角色的方法。
sub.Request();
輸出：
class $Proxy0 新建的代理對象，它實現指定的接口
Method:public abstract void DynamicProxy.Subject.Request(),Args:null
RealSubject 調用的真實對象的方法