最近看源碼時發現很多地方使用的反射機制,一直對這個反射機制不太清楚,今天花一點時間看了看,敲了敲反射的使用方法;
兩個類:Main.class,Person.class;
Main.class實現各種方法的測試。
Person三個私有成員變量:name、age、sex;其中sex的set方法為私有方法;其他getter和setter都是public;兩個構造函數,一個無參數,一個參數為name和age;
package reflect;
public class Person {
private String name;
private int age;
private String sex;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private void setSex(String sex) {
this.sex = sex;
}
public String getSex() {
return sex;
}
public void sayPerson(String name, int age) {
System.out.println(name+ " " + age);
}
@Override
public String toString() {
return getName() + " " + getSex() + " " + getAge();
}
}
構造函數的反射調用
public static void testConstructor() {
Class<?> person = null;
try {
//獲取到類對象
person = Class.forName("reflect.Person");
} catch (Exception e) {
e.printStackTrace();
}
try {
//獲取構造函數(String,int)
Constructor cons = person.getConstructor(String.class,int.class);
System.out.println(cons.newInstance("AA", 15));
//獲取無參構造函數()
Constructor cons2 = person.getConstructor();
System.out.println(cons2.newInstance());
} catch (Exception e) {
e.printStackTrace();
}
//獲取構造函數列表
Constructor<?>[] t = person.getConstructors();
for (Constructor a : t)
System.out.println(a);
}
輸出
AA null 15
null null 0
public reflect.Person(java.lang.String,int)
public reflect.Person()
成員變量的反射set和get
private static void testFeild() {
//設置只有名字和年齡的對象
Person person = new Person("AA", 12);
try {
person.getClass().getFields();
//注意getDeclaredFields和 getFields的區別
Field[] fields = person.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
//打印所有的成員變量
System.out.println(fields[i]);
//設置字段可訪問
fields[i].setAccessible(true);
//設置對象的成員變量值
if (i == 0)
fields[i].set(person, "BB");
else if (i == 1) {
fields[i].set(person, 17);
} else if (i == 2) {
fields[i].set(person, "女");
}
//打印對象的成員變量值
System.out.println(fields[i].get(person));
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(person);
}
輸出
public java.lang.String reflect.Person.name
BB
private int reflect.Person.age
int
17
private java.lang.String reflect.Person.sex
女
BB 女 17
成員方法的調用
private static void testMethod() {
Person person = new Person("AA", 12);
try {
Method method = person.getClass().getDeclaredMethod("setSex", String.class);
//私有成員變量必須要設置可訪問才能調用
method.setAccessible(true);
method.invoke(person, "男");
System.out.println(person);
Method method1 = person.getClass().getDeclaredMethod("sayPerson", String.class, int.class);
method1.invoke(person, "張三", 22);
} catch (Exception e) {
e.printStackTrace();
}
}
輸出
AA 男 12
張三 22
getDeclaredFields和 getFields的區別
private static void testAiffGetFeildsAndGetDeclaredFields() {
//設置只有名字和年齡的對象
Person person = new Person("AA", 12);
try {
person.getClass().getFields();
//注意getDeclaredFields和 getFields的區別
Field[] fields = person.getClass().getDeclaredFields();
Field[] fields2 = person.getClass().getFields();
for (int i = 0; i < fields.length; i++) {
System.out.println(fields[i]);
}
for (int i = 0; i < fields.length; i++) {
System.out.println(fields2[i]);
}
} catch (Exception e) {
e.printStackTrace();
}
}
輸出
private java.lang.String reflect.Person.name
private int reflect.Person.age
private java.lang.String reflect.Person.sex
可以看到輸出的只有三個,也就是說fields2 為空;我們將Person的name字段更改為public,再進行測試輸出如下:
public java.lang.String reflect.Person.name
private int reflect.Person.age
private java.lang.String reflect.Person.sex
public java.lang.String reflect.Person.name
輸出4個數據,其中為name的數據顯示的兩條,此兩條數據都是public類型;
因此getFields獲取的數據為public字段,getDeclaredFields則獲取了所有的字段;
getEnclosingClass()、getEnclosingConstructor()、getEnclosingMethod()的區別;
都是與內部類所在代碼位置相關的函數;
getEnclosingClass():獲取該類在那個類中定義;
getEnclosingConstructor():該類在哪個構造函數中定義;
getEnclosingMethod():該類在哪個方法中定義的;
invoke方法分析
@CallerSensitive
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
override是什么呢,查看源碼是 method.setAccessible(true)設置該值,當設置為true,就可以忽略權限進行訪問,這也就是為什么private要訪問必須設置此標志的原因;
Reflection.quickCheckMemberAccess(clazz, modifiers)代碼查看,確實是判斷是不是public成員的:
public static boolean quickCheckMemberAccess(Class<?> var0, int var1) {
return Modifier.isPublic(getClassAccessFlags(var0) & var1);
}
checkAccess(caller, clazz, obj, modifiers);是判斷不是public情況下,是否為該類(有可以子類的情況),再去判斷是不是protected,同時對該類進行緩存,下一次調用此類就可以直接使用;
MethodAccessor是方法訪問對象接口,在為null的情況下通過acquireMethodAccessor()函數實例化實現類;最后調用實現類的invoke;acquireMethodAccessor()代碼如下:
private MethodAccessor acquireMethodAccessor() {
// First check to see if one has been created yet, and take it
// if so
MethodAccessor tmp = null;
if (root != null) tmp = root.getMethodAccessor();/*此處的root就是該方法對象*/
if (tmp != null) {
methodAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newMethodAccessor(this);
setMethodAccessor(tmp);
}
return tmp;
}
該方法以工廠模式ReflectionFactory來獲得MethodAccessor 對象,
tmp = reflectionFactory.newMethodAccessor(this);
public MethodAccessor newMethodAccessor(Method var1) {
checkInitted();
if (noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())) {
return (new MethodAccessorGenerator()).generateMethod(var1.getDeclaringClass(), var1.getName(), var1.getParameterTypes(), var1.getReturnType(), var1.getExceptionTypes(), var1.getModifiers());
} else {
NativeMethodAccessorImpl var2 = new NativeMethodAccessorImpl(var1);
DelegatingMethodAccessorImpl var3 = new DelegatingMethodAccessorImpl(var2);
var2.setParent(var3);
return var3;
}
}
如果noInflation的屬性為true,則直接返回MethodAccessorGenerator創建的一個MethodAccessor。
否則返回DelegatingMethodAccessorImpl,并將他與一個NativeMethodAccessorImpl互相引用。但DelegatingMethodAccessorImpl執行invoke方法的時候又委托給NativeMethodAccessorImpl,因此最終是NativeMethodAccessorImpl調用了的invoke()。NativeMethodAccessorImpl的invoke代碼如下:
public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
this.parent.setDelegate(var3);
}
return invoke0(this.method, var1, var2);
}
其中numInvocations 是對該方法的調用次數的累積,若是numInvocations 計數調用次數超過ReflectionFactory.inflationThreshold()==15,則更改DelegatingMethodAccessorImpl的委托對象,由new MethodAccessorGenerator()生成的MethodAccessor對象代理,調用其invoke();
為什么要有這個15次的計數呢?這就是MethodAccessorGenerator()生成的MethodAccessor與NativeMethodAccessorImpl生成的MethodAccessor有區別;什么區別呢?
可以看到MethodAccessorGenerator()是通過java直接生成的,NativeMethodAccessorImpl則是用native生成的;
Java實現的版本在初始化時需要較多時間,但長久來說性能較好;native版本正好相反,啟動時相對較快,但運行時間長了之后速度就比不過Java版了。這是HotSpot的優化方式帶來的性能特性,同時也是許多虛擬機的共同點:跨越native邊界會對優化有阻礙作用,它就像個黑箱一樣讓虛擬機難以分析也將其內聯,于是運行時間長了之后反而是托管版本的代碼更快些。
為保持最好特性,前15次使用native,之后使用java版本;
該方法學習根據源碼結合寂靜沙灘的JAVA深入研究——Method的Invoke方法]