首先，我們在開始前提出一個問題：
1.在運行時，對于一個java類，能否知道屬性和方法；能否去調(diào)用它的任意方法？ 答案是肯定的。
本節(jié)所有目錄如下：
什么是JAVA的反射機制JDK中提供的Reflection APIJAVA反射機制提供了什么功能獲取類的Class對象獲取類的Fields獲取類的Method獲取類的Constructor新建類的實例 Class<T>的函數(shù)newInstance 通過Constructor對象的方法newInstance調(diào)用類的函數(shù) 調(diào)用PRivate函數(shù)設(shè)置/獲取類的屬性值 private屬性動態(tài)創(chuàng)建代理類 動態(tài)代理源碼分析JAVA反射Class<T>類型源代碼分析JAVA反射原理分析 Class文件結(jié)構(gòu) JVM加載類對象，對反射的支持JAVA反射的應(yīng)用一、什么是JAVA的反射機制
Java反射是Java被視為動態(tài)（或準動態(tài)）語言的一個關(guān)鍵性質(zhì)。這個機制允許程序在運行時透過Reflection APIs取得任何一個已知名稱的class的內(nèi)部信息，包括其modifiers（諸如public, static 等）、superclass（例如Object）、實現(xiàn)之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于運行時改變fields內(nèi)容或喚起methods。
Java反射機制容許程序在運行時加載、探知、使用編譯期間完全未知的classes。
換言之，Java可以加載一個運行時才得知名稱的class，獲得其完整結(jié)構(gòu)。
二、JDK中提供的Reflection API
Java反射相關(guān)的API在包java.lang.reflect中，JDK 1.6.0的reflect包如下圖：
| Member接口 | 該接口可以獲取有關(guān)類成員（域或者方法）后者構(gòu)造函數(shù)的信息。 |
| accessibleObject類 | 該類是域(field)對象、方法(method)對象、構(gòu)造函數(shù)(constructor)對象的基礎(chǔ)類。它提供了將反射的對象標記為在使用時取消默認 Java 語言訪問控制檢查的能力。 |
| Array類 | 該類提供動態(tài)地生成和訪問JAVA數(shù)組的方法。 |
| Constructor類 | 提供一個類的構(gòu)造函數(shù)的信息以及訪問類的構(gòu)造函數(shù)的接口。 |
| Field類 | 提供一個類的域的信息以及訪問類的域的接口。 |
| Method類 | 提供一個類的方法的信息以及訪問類的方法的接口。 |
| Modifier類 | 提供了 static 方法和常量，對類和成員訪問修飾符進行解碼。 |
| Proxy類 | 提供動態(tài)地生成代理類和類實例的靜態(tài)方法。 |
三、JAVA反射機制提供了什么功能
Java反射機制提供如下功能：
在運行時判斷任意一個對象所屬的類
在運行時構(gòu)造任意一個類的對象
在運行時判段任意一個類所具有的成員變量和方法
在運行時調(diào)用任一個對象的方法
在運行時創(chuàng)建新類對象
在使用Java的反射功能時，基本首先都要獲取類的Class對象，再通過Class對象獲取其他的對象。
這里首先定義用于測試的類:
[java] view plain copy print?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 應(yīng)用程序中的類和接口。獲取類的Class對象有多種方式：
| 調(diào)用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
可以通過反射機制得到某個類的某個屬性，然后改變對應(yīng)于這個類的某個實例的該屬性值。JAVA 的Class<T>類提供了幾個方法獲取類的屬性。
| public FieldgetField(String name) | 返回一個 Field 對象，它反映此 Class 對象所表示的類或接口的指定公共成員字段 |
| public Field[] getFields() | 返回一個包含某些 Field 對象的數(shù)組，這些對象反映此 Class 對象所表示的類或接口的所有可訪問公共字段 |
| public FieldgetDeclaredField(Stringname) | 返回一個 Field 對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明字段 |
| public Field[] getDeclaredFields() | 返回 Field 對象的一個數(shù)組，這些對象反映此 Class 對象所表示的類或接口所聲明的所有字段 |
[java] view plain copy print?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區(qū)別：
getFields返回的是申明為public的屬性，包括父類中定義，
getDeclaredFields返回的是指定類定義的所有定義的屬性，不包括父類的。
3、獲取類的Method
通過反射機制得到某個類的某個方法，然后調(diào)用對應(yīng)于這個類的某個實例的該方法
Class<T>類提供了幾個方法獲取類的方法。
| public MethodgetMethod(String name,Class<?>... parameterTypes) | 返回一個 Method 對象，它反映此 Class 對象所表示的類或接口的指定公共成員方法 |
| public Method[] getMethods() | 返回一個包含某些 Method 對象的數(shù)組，這些對象反映此 Class 對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共 member 方法 |
public MethodgetDeclaredMethod(Stringname,Class<?>... parameterTypes) | 返回一個 Method 對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法 |
| public Method[] getDeclaredMethods() | 返回 Method 對象的一個數(shù)組，這些對象反映此 Class 對象表示的類或接口聲明的所有方法，包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法 |
[java] view plain copy print?// 使用getMethods獲取函數(shù) Class<?> classType = ExtendType.class; Method[] methods = classType.getMethods(); for (Method m : methods) { System.out.println(m); } System.out.println(); // 使用getDeclaredMethods獲取函數(shù) 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
通過反射機制得到某個類的構(gòu)造器，然后調(diào)用該構(gòu)造器創(chuàng)建該類的一個實例
Class<T>類提供了幾個方法獲取類的構(gòu)造器。
| public Constructor<T> getConstructor(Class<?>... parameterTypes) | 返回一個 Constructor 對象，它反映此 Class 對象所表示的類的指定公共構(gòu)造方法 |
| public Constructor<?>[] getConstructors() | 返回一個包含某些 Constructor 對象的數(shù)組，這些對象反映此 Class 對象所表示的類的所有公共構(gòu)造方法 |
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) | 返回一個 Constructor 對象，該對象反映此 Class 對象所表示的類或接口的指定構(gòu)造方法 |
public Constructor<?>[] getDeclaredConstructors() | 返回 Constructor 對象的一個數(shù)組，這些對象反映此 Class 對象表示的類聲明的所有構(gòu)造方法。它們是公共、保護、默認（包）訪問和私有構(gòu)造方法 |
[java] view plain copy print?// 使用getConstructors獲取構(gòu)造器 Constructor<?>[] constructors = classType.getConstructors(); for (Constructor<?> m : constructors) { System.out.println(m); } System.out.println(); // 使用getDeclaredConstructors獲取構(gòu)造器 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、新建類的實例
通過反射機制創(chuàng)建新類的實例，有幾種方法可以創(chuàng)建
| 調(diào)用無自變量ctor | 1、調(diào)用類的Class對象的newInstance方法，該方法會調(diào)用對象的默認構(gòu)造器，如果沒有默認構(gòu)造器，會調(diào)用失敗. Class<?> classType = ExtendType.class; Object inst = classType.newInstance(); System.out.println(inst); 輸出： Type:Default Constructor ExtendType:Default Constructor com.quincy.ExtendType@d80be3
2、調(diào)用默認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 |
| 調(diào)用帶參數(shù)ctor | 3、調(diào)用帶參數(shù)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、調(diào)用類的函數(shù)
通過反射獲取類Method對象，調(diào)用Field的Invoke方法調(diào)用函數(shù)。
[java] view plain copy print?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">上面失敗是由于沒有權(quán)限調(diào)用private函數(shù)，這里需要設(shè)置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、設(shè)置/獲取類的屬性值
通過反射獲取類的Field對象，調(diào)用Field方法設(shè)置或獲取值
[java] view plain copy print?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);四、動態(tài)創(chuàng)建代理類
代理模式：代理模式的作用=為其他對象提供一種代理以控制對這個對象的訪問。
代理模式的角色：
抽象角色：聲明真實對象和代理對象的共同接口
代理角色：代理角色內(nèi)部包含有真實對象的引用，從而可以操作真實對象。
真實角色：代理角色所代表的真實對象，是我們最終要引用的對象。
動態(tài)代理：
java.lang.reflect.Proxy Proxy 提供用于創(chuàng)建動態(tài)代理類和實例的靜態(tài)方法，它還是由這些方法創(chuàng)建的所有動態(tài)代理類的超類
InvocationHandler 是代理實例的調(diào)用處理程序 實現(xiàn)的接口，每個代理實例都具有一個關(guān)聯(lián)的調(diào)用處理程序。對代理實例調(diào)用方法時，將對方法調(diào)用進行編碼并將其指派到它的調(diào)用處理程序的 invoke 方法。
動態(tài)Proxy是這樣的一種類:
它是在運行生成的類，在生成時你必須提供一組Interface給它，然后該class就宣稱它實現(xiàn)了這些interface。你可以把該class的實例當作這些interface中的任何一個來用。當然，這個Dynamic Proxy其實就是一個Proxy，它不會替你作實質(zhì)性的工作，在生成它的實例時你必須提供一個handler，由它接管實際的工作。
在使用動態(tài)代理類時，我們必須實現(xiàn)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構(gòu)建代理對象
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、通過調(diào)用代理對象的方法去調(diào)用真實角色的方法。
sub.Request();
輸出：
class $Proxy0 新建的代理對象，它實現(xiàn)指定的接口
Method:public abstract void DynamicProxy.Subject.Request(),Args:null
RealSubject 調(diào)用的真實對象的方法
新聞熱點
疑難解答
