java invoke源码_java class Method 反射 invoke方法源码分析

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版了

结语，致名言： 路漫漫其修远兮，吾将上下而求索