1.要搞清楚的问题？
Method的invoke方法底层是如何实现的。
2.先来看一个例子
package arithmetics;
public class AgentToolsTest {
public void hello(int i) {
System.err.println("第" + i+" 次 hello");
}
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("arithmetics.AgentToolsTest");
for(int i=0;i<20;i++) {
clazz.getDeclaredMethod("hello", int.class).invoke(clazz.newInstance(), i);
}
}
}
程序很简单，接下来我们加上虚拟机参数 -verbose:class 启动执行如下：
[Loaded sun.reflect.DelegatingMethodAccessorImpl from E:\java8\jre\lib\rt.jar]
第0 次 hello
第1 次 hello
第2 次 hello
第3 次 hello
第4 次 hello
第5 次 hello
第6 次 hello
第7 次 hello
第8 次 hello
第9 次 hello
第10 次 hello
第11 次 hello
第12 次 hello
第13 次 hello
第14 次 hello
[Loaded sun.reflect.ClassFileConstants from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.AccessorGenerator from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.MethodAccessorGenerator from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ByteVectorFactory from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ByteVector from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ByteVectorImpl from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ClassFileAssembler from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.UTF8 from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.Label from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.Label$PatchInfo from E:\java8\jre\lib\rt.jar]
[Loaded java.util.ArrayList$Itr from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.MethodAccessorGenerator$1 from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ClassDefiner from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.ClassDefiner$1 from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.GeneratedConstructorAccessor1 from __JVM_DefineClass__]
[Loaded sun.reflect.BootstrapConstructorAccessorImpl from E:\java8\jre\lib\rt.jar]
[Loaded java.util.concurrent.ConcurrentHashMap$ForwardingNode from E:\java8\jre\lib\rt.jar]
[Loaded sun.reflect.GeneratedMethodAccessor1 from __JVM_DefineClass__]
第15 次 hello
第16 次 hello
第17 次 hello
第18 次 hello
第19 次 hello
[Loaded java.lang.Shutdown from E:\java8\jre\lib\rt.jar]
[Loaded java.lang.Shutdown$Lock from E:\java8\jre\lib\rt.jar]
我们发现执行到第14次的时候会又多加载一部分类，这说明从第前15次和后面的反射调用方式是不同的，我们看看源码来一探究竟。
// invoke方法入口 ,省略部分代码
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
//构造MethodAccessor
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
invoke方法其实就是加载MethodAccessor，然后调用其invoke方法。
private MethodAccessor acquireMethodAccessor() {
MethodAccessor tmp = null;
//第一次进来root.getMethodAccessor()为空
if (root != null) tmp = root.getMethodAccessor();
if (tmp != null) {
methodAccessor = tmp;
} else {
// 构造MethodAccessor
tmp = reflectionFactory.newMethodAccessor(this);
//将构造的MethodAccessor 设置进root的MethodAccessor
setMethodAccessor(tmp);
}
return tmp;
}
通过ReflectionFactory工厂类来构造MethodAccessor ，这里第一次调用走ReflectionFactory工厂的构造，后面进来就直接用root.getMethodAccessor()缓存。
public MethodAccessor newMethodAccessor(Method var1) {
// native实现版本
NativeMethodAccessorImpl var2 = new NativeMethodAccessorImpl(var1);
// 构造一个委派类
DelegatingMethodAccessorImpl var3 = new DelegatingMethodAccessorImpl(var2);
var2.setParent(var3);
return var3;
}
//委派类 , 实际是调用内部delegate属性的invoke来实现的
class DelegatingMethodAccessorImpl extends MethodAccessorImpl {
private MethodAccessorImpl delegate;
DelegatingMethodAccessorImpl(MethodAccessorImpl var1) {
this.setDelegate(var1);
}
public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
return this.delegate.invoke(var1, var2);
}
void setDelegate(MethodAccessorImpl var1) {
this.delegate = var1;
}
}
class NativeMethodAccessorImpl extends MethodAccessorImpl {
private final Method method;
private DelegatingMethodAccessorImpl parent;
private int numInvocations;
public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
//当执行次数numInvocations 大于了某个值 就不走native方法的invoke了
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());
//委派的类 切换成 java里面的
this.parent.setDelegate(var3);
}
//走native的invoke方法
return invoke0(this.method, var1, var2);
}
private static native Object invoke0(Method var0, Object var1, Object[] var2);
void setParent(DelegatingMethodAccessorImpl var1) {
this.parent = var1;
}
}
在1-15次内调用invoke时，走native调用
在1-15次内是通过调用DelegatingMethodAccessorImpl 委派类的invoke， 委派的具体类是NativeMethodAccessorImpl，此类就会调用native方法的invoke0，执行方法调用。
在大于15次调用invoke时，动态生成类走java调用
当在15以上时，NativeMethodAccessorImpl内部的invoke会判断次数超过13后会切换 委派类 的具体类为
new MethodAccessorGenerator().generateMethod(..) 生成的类，它的基本工作就是在内存里生成新的专用Java类，并将其加载。
总结：Java实现的版本在初始化时需要较多时间，但长久来说性能较好；native版本正好相反，启动时相对较快，但运行时间长了之后速度就比不过Java版了
结语，致名言： 路漫漫其修远兮，吾将上下而求索
