最近看源码时发现很多地方使用的反射机制，一直对这个反射机制不太清楚，今天花一点时间看了看，敲了敲反射的使用方法；
两个类：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方法]
