java 反射 Method invoke 源码分析

1.先来看一个例子

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次和后面的反射调用方式是不同的，我们看看源码来一探究竟。

2.源码阅读

java.lang.reflect.Method的invoke方法入口

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

强烈推荐一套Java进阶博客，走向架构师不是梦

Java进阶全套博客