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方法入口

eclipse-javadoc:☂=hadluo-test/E:\/java8\/jre\/lib\/rt.jar

eclipse-javadoc:☂=hadluo-test/E:\/java8\/jre\/lib\/rt.jar

eclipse-javadoc:☂=hadluo-test/E:\/java8\/jre\/lib\/rt.jar

// 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以上时,NativeMethodAccessorImpl内部的invoke会判断次数超过13后会切换 委派类 的具体类为

new MethodAcce 在大于15次调用invoke时,动态生成类走java调用

ssorGenerator().generateMethod(..) 生成的类,它的基本工作就是在内存里生成新的专用Java类,并将其加载。


总结:Java实现的版本在初始化时需要较多时间,但长久来说性能较好;native版本正好相反,启动时相对较快,但运行时间长了之后速度就比不过Java版了



强烈推荐一个走向Java架构师道路的博客


Java架构师修炼



《 静胜躁,寒胜热。清静为天下正 》

释义:静的胜动的,冷的胜热的,人静才是正为才是根本。

支付宝打赏 微信打赏

如果文章对您有帮助,您可以鼓励一下作者