java怎么样实现反射_JVM是如何实现Java反射的？

Java的反射应用场景非常多，例如IDE在做联想时，Spring的IoC容器等等。

通过反射，我们可以做一些平时做不到的事儿，例如调用其他对象的私有方法，获取其任意属性，总之在反射面前，任何Java对象都毫无隐私可言。

反射调用的实现

我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。

public Object invoke(Object obj, Object... args)

throws IllegalAccessException, IllegalArgumentException,

InvocationTargetException

{

// 权限检查，忽略 ...

if (!override) {

if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

Class> caller = Reflection.getCallerClass();

checkAccess(caller, clazz, obj, modifiers);

}

}

// 看这里 ...

MethodAccessor ma = methodAccessor; // read volatile

if (ma == null) {

ma = acquireMethodAccessor();

}

return ma.invoke(obj, args);

}

可以看到，这里讲方法的调用，委派给了MethodAccessor类型的ma对象来处理。它是一个接口，有两个实现类。一个委派实现(DelegatingMethodAccessorImpl)，一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用，都会使用委派实现！，但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下：

/**

* @author gzd

* @date 2018-09-09 下午5:59

* @desc 观察本地实现和委派实现

*/

public class HowReflect {

public static void targetMethod(int i) {

// 打印调用栈

new Exception("version " + i)

.printStackTrace();

}

public static void main(String[] args) throws Exception {

Class> howReflect = Class.forName("com.ynwa.jvm.HowReflect");

Method method = howReflect.getMethod("targetMethod", int.class);

// 执行方法

method.invoke(null, 0);

}

}

上面的代码运行结果为：

java.lang.Exception: 版本 0

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

// 4 委派实现又委派给了本地实现

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

// 3 生成委派实现

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

// 2 反射调用方法

at java.lang.reflect.Method.invoke(Method.java:498)

// 1 执行main方法

at com.ynwa.jvm.HowReflect.main(HowReflect.java:21)

上面在结果打印的调用栈中，注释的第3步个第4步，可以看到先用的委派实现，委派实现又委派了本地实现！

那么问题来了！既然最终要用本地实现，那么为什么中间要加一层委派实现？，那么继续向下看。

其实这是因为除了以上两种以外，还有一种动态实现，而所谓的委派实现，只不过是为了能够在本地实现和动态实现之间做切换。动态实现是一种字节码技术。

但是如果只调用一次的话，本地实现要比动态实现块一点儿，这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次)，所以它设定了一个阀值：16，如果调用15此以上，也就是说第17次开始，使用动态实现。使用本地实现的时候，因为要经过Java -> c++ -> Java的过程。第17次开始，JVM会利用已经生成的字节码来进行方法调用，所以这无疑就会增速很多！

下面来循环20次上面的代码，直观的看一下，这个过程：

/**

* @author gzd

* @date 2018-09-09 下午5:59

* @desc 观察本地实现和委派实现

*/

public class HowReflect {

public static void targetMethod(int i) {

// 打印调用栈

new Exception("版本 " + i)

.printStackTrace();

}

public static void main(String[] args) throws Exception {

Class> howReflect = Class.forName("com.ynwa.jvm.HowReflect");

Method method = howReflect.getMethod("targetMethod", int.class);

for (int i = 0; i < 20; i++) {

// 执行方法

method.invoke(null, i);

}

}

}

下面是执行结果：

java.lang.Exception: 版本 0

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 1

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

// 省略 2 -14 次 ... ... ...

java.lang.Exception: 版本 15

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

// 0 -15 次还是使用的本地实现

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 16

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

// 开始使用动态实现 ！

at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 17

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 18

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 19

at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)

at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:498)

at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

从结果中可以看到，"版本 17" 开始，使用了动态实现。

反射调用的开销

刚才的代码中，Class.forName会调用本地方法，getMethod会遍历所有的共有方法，如果找不到则会去父类找，这些操作都比较费时。如果将上面的代码改造一下，运行一亿次的话，我的电脑结果为550ms。而直接调用只需要5ms。可以看出差距非常大，不过实验比较简陋，比如其他进程的影响，没考虑方法内联，还有Interger的数据缓存等等。

下面的改造后的局部代码：

public static void targetMethod(int i) {

// 打印调用栈

// new Exception("版本 " + i)

// .printStackTrace();

}

public static void main(String[] args) throws Exception {

Class> howReflect = Class.forName("com.ynwa.jvm.HowReflect");

Method method = howReflect.getMethod("targetMethod", int.class);

long start = System.currentTimeMillis();

for (int i = 0; i < 100000000; i++) {

// 直接执行方法

// targetMethod(128);

// 反射调用

method.invoke(i);

}

long end = System.currentTimeMillis();

System.out.println("耗时：" + (end - start));

}