【06】JVM是如何实现反射的？

为了保证框架的可扩展性，往往借助 Java 的反射机制，根据配置文件来加载不同的类。Spring 框架的依赖反转（IoC），便是依赖于反射机制。

反射调用的实现

这里主要是以【方法的反射调用】来进行剖析

public final class Method extends Executable {
  ...
  public Object invoke(Object obj, Object... args) throws ... {
    ... // 权限检查
    MethodAccessor ma = methodAccessor;
    if (ma == null) {
      ma = acquireMethodAccessor();
    }
    return ma.invoke(obj, args);
  }
}

Mehton.invoke内部是通过MethodAccessor来进行真正的实现，MethodAccessor是一个接口，它的具体实现有两个:

• 本地实现：通过本地方法来实现反射调用
• 委托实现：委派模式实现

每个Method实例第一次反射调用都会生成一个委派实现，所委派的具体实现是一个本地实现。

// v0 版本
import java.lang.reflect.Method;

public class Test {
  public static void target(int i) {
    new Exception("#" + i).printStackTrace();
  }

  public static void main(String[] args) throws Exception {
    Class<?> klass = Class.forName("Test");
    Method method = klass.getMethod("target", int.class);
    method.invoke(null, 0);
  }
}

# 不同版本的输出略有不同，这里我使用了 Java 10。
$ java Test
java.lang.Exception: #0
        at Test.target(Test.java:5)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke0(Native Method)
        //本地实现
       at java.base/jdk.internal.reflect.NativeMethodAccessorImpl. .invoke(NativeMethodAccessorImpl.java:62)
        //委托实现
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.i .invoke(DelegatingMethodAccessorImpl.java:43)
 
        java.base/java.lang.reflect.Method.invoke(Method.java:564)
        at Test.main(Test.java:131

Method.invoke的执行序列图如下：

注意到这里通过代理类DelegatingMethodAccessorImpl作为一个中间层来对NativeMethodAccessorImpl进行代理，目的是能够在本地实现与动态实现（Java的反射调用机制还设立了另一种动态生成字节码的实现，直接使用invoke指令来调用目标方法）进行一个切换。

动态实现和本地实现相比，其运行效率要快上 20 倍 这是因为动态实现无需经过 Java 到 C++ 再到 Java的切换，但由于生成字节码十分耗时，仅调用一次的话，反而是本地实现要快3到4倍。考虑到许多反射调用仅会执行一次，Java 虚拟机设置了一个阈值15（Dsun.reflect.inflationThreshold控制）
当某个反射调用的调用次数在 15 之下时，采用本地实现；当达到15时，便开始动态生成字节码，并将委派实现的委派对象切换至动态实现，这个过程我们称之为 Inflation

下面看下代码

// v1 版本
import java.lang.reflect.Method;

public class Test {
  public static void target(int i) {
    new Exception("#" + i).printStackTrace();
  }

  public static void main(String[] args) throws Exception {
    Class<?> klass = Class.forName("Test");
    Method method = klass.getMethod("target", int.class);
    for (int i = 0; i < 20; i++) {
      method.invoke(null, i);
    }
  }
}

# 使用 -verbose:class 打印加载的类
$ java -verbose:class Test
...
java.lang.Exception: #14
        at Test.target(Test.java:5)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke0(Native Method)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke(NativeMethodAccessorImpl.java:62)
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl .invoke(DelegatingMethodAccessorImpl.java:43)
        at java.base/java.lang.reflect.Method.invoke(Method.java:564)
        at Test.main(Test.java:12)
[0.158s][info][class,load] ...
...
[0.160s][info][class,load]
//这里触发动态实现的生成，加载了GeneratedMethodAccessor1类
jdk.internal.reflect.GeneratedMethodAccessor1 source: __JVM_DefineClass__
java.lang.Exception: #15
       at Test.target(Test.java:5)
       at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke0(Native Method)
       at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke(NativeMethodAccessorImpl.java:62)
       at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl .invoke(DelegatingMethodAccessorImpl.java:43)
       at java.base/java.lang.reflect.Method.invoke(Method.java:564)
       at Test.main(Test.java:12)
java.lang.Exception: #16
       at Test.target(Test.java:5)
       //直接通过GeneratedMethodAccessor1类来进行invoke
       at jdk.internal.reflect.GeneratedMethodAccessor1 .invoke(Unknown Source)
       at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl .invoke(DelegatingMethodAccessorImpl.java:43)
       at java.base/java.lang.reflect.Method.invoke(Method.java:564)
       at Test.main(Test.java:12)
...

反射调用的开销

方法的反射调用会带来不少的性能开销，原因主要是三个

• 变长参数方法导致的Object数据
• 基本类型的自动装拆箱
• 方法内联