《深入理解Java虚拟机》- JVM是如何实现反射的
Java反射学问很深，这里就浅谈吧。如果涉及到方法内联，逃逸分析的话，我们就说说是什么就好了。有兴趣的可以去另外看看，我后面可能也会写一下。（因为我也不会呀~）
一、Java反射是什么？
反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。
反射是由类开始的，从class对象中，我们可以获得有关该类的全部成员的完整列表；可以找出该类的所有类型、类自身信息。
二、反射的一些应用
1、java集成开发环境，每当我们敲入点号时，IDE便会根据点号前的内容，动态展示可以访问的字段和方法。
2、java调试器，它能够在调试过程中枚举某一对象所有字段的值。
3、web开发中，我们经常接触到各种配置的通用框架。为保证框架的可扩展性，他往往借助java的反射机制。例如Spring框架的依赖反转（IOC）便是依赖于反射机制。
三、Java反射的实现
1. Java反射使用的api（列举部分，具体在rt.jar包的java.lang.reflect.*）中
列举Class.java中的一些方法。这些都很常用，比如在你尝试编写一个mvc框架的时候，就可以参照这个类里面的方法，再结合一些Servlet的api就实现一个简单的框架。
2.代码实现
2.1代码实现的目的：说明反射调用是有两种方式，一种是本地实现，另一种是委派实现。
这里围绕Method.invoke方法展开。查看invoke()源码：
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); }
说明：invoke()是有MethodAccessor接口实现的，这个接口有俩实现：
一个是使用委派模式的“委派实现”，一个是通过本地方法调用来实现反射调用的“本地实现”。
这两种实现不是独立的，而是相互协作的。下面，用代码让大家看一下具体操作。
Java代码：
public class InvokeDemo { public static void target(int i){ new Exception("#"+i).printStackTrace(); } public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo"); Method method1 = invokeDemo1.getMethod("target", int.class); method1.invoke(null,0); } }
运行之后，便可以在异常栈中查找方法调用的路线：
java.lang.Exception: #0 at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9) 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.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:15)
这里，我们会看到，invoke方法是先调用委派实现，然后再将请求传到本地方法实现的，最后在传到目标方法使用。
为什么要这样做呢？为什么不直接调用本地方法呢？
其实，Java的反射调用机制还设立了另一种动态生成字节码的实现（“动态实现”），直接使用invoke指令来调用目标方法。之所以采用委派实现，便是为了能够在“本地实现”和动态实现之间来回切换。（但是，动态实现貌似并没有开源）
动态实现与本地实现的区别在于，反射代码段重复运行15次以上就会使用动态实现，15次以下就使用本地实现。下面是重复这个代码的控制台输出的第#14、#15、#16段异常：
Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo");
Method method1 = invokeDemo1.getMethod("target", int.class);
method1.invoke(null,0);
控制台：
java.lang.Exception: #15 at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9) 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.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20) java.lang.Exception: #16 at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9) 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.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20) java.lang.Exception: #17 at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9) 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.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20)
从#15到#16异常链路看，反射的调用就开始从本地实现向动态实现的转变。这 是JVM对反射调用进行辨别优化性能的一个手段。
另外注意一点，粉红色部分的字体，标记为“unkown source" ，那就是不开源的吧，所以看不到那是啥。。
四、Java反射的性能开销
public class InvokeDemo { private static long n = 0; public static void target(int i){ n++; } /* 8662ms public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo"); Method method1 = invokeDemo1.getMethod("target", int.class); long start = System.currentTimeMillis(); for (int i = 0; i < 1000000000; i++) { if(i==1000000000-1){ long total = System.currentTimeMillis()-start; System.out.println(total); } method1.invoke(null,1); } } */ // 161ms public static void main(String[] args) { long start = System.currentTimeMillis(); for (int i = 0; i < 1000000000; i++) { if(i==1000000000-1){ long total = System.currentTimeMillis()-start; System.out.println(total); } target(1); } } }
上面展示了使用反射调用和不使用反射调用的性能，结果表示，使用反射的耗时为8662ms，而不使用反射的耗时为161ms。这里就可以看到差异。
那么从字节码层面查看，又是什么样的一种风景呢？
1.不使用反射：
public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=4, locals=6, args_size=1 0: invokestatic #3 // Method java/lang/System.currentTimeMillis:()J 3: lstore_1 4: iconst_0 5: istore_3 6: iload_3 7: ldc #4 // int 1000000000 9: if_icmpge 43 12: iload_3 13: ldc #5 // int 999999999 15: if_icmpne 33 18: invokestatic #3 // Method java/lang/System.currentTimeMillis:()J 21: lload_1 22: lsub 23: lstore 4 25: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; 28: lload 4 30: invokevirtual #7 // Method java/io/PrintStream.println:(J)V 33: iconst_1 34: invokestatic #8 // Method target:(I)V 37: iinc 3, 1 40: goto 6 43: return LineNumberTable: line 8: 0 line 9: 4 line 10: 12 line 11: 18 line 12: 25 line 14: 33 line 9: 37 line 16: 43 StackMapTable: number_of_entries = 3 frame_type = 253 /* append */ offset_delta = 6 locals = [ long, int ] frame_type = 26 /* same */ frame_type = 250 /* chop */ offset_delta = 9
2.使用反射：
public static void main(java.lang.String[]) throws java.lang.ClassNotFoundException, java.lang.NoSuchMethodException, java.lang.reflect.InvocationTargetException, java.lang.IllegalAccessException; descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=6, locals=8, args_size=1 0: ldc #3 // String InvokeDemo2 2: invokestatic #4 // Method java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class; 5: astore_1 6: aload_1 7: ldc #5 // String target 9: iconst_1 10: anewarray #6 // class java/lang/Class 13: dup 14: iconst_0 15: getstatic #7 // Field java/lang/Integer.TYPE:Ljava/lang/Class; 18: aastore 19: invokevirtual #8 // Method java/lang/Class.getMethod:(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method; 22: astore_2 23: invokestatic #9 // Method java/lang/System.currentTimeMillis:()J 26: lstore_3 27: iconst_0 28: istore 5 30: iload 5 32: ldc #10 // int 1000000000 34: if_icmpge 82 37: iload 5 39: ldc #11 // int 999999999 41: if_icmpne 59 44: invokestatic #9 // Method java/lang/System.currentTimeMillis:()J 47: lload_3 48: lsub 49: lstore 6 51: getstatic #12 // Field java/lang/System.out:Ljava/io/PrintStream; 54: lload 6 56: invokevirtual #13 // Method java/io/PrintStream.println:(J)V 59: aload_2 60: aconst_null 61: iconst_1 62: anewarray #14 // class java/lang/Object 65: dup 66: iconst_0 67: iconst_1 68: invokestatic #15 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 71: aastore 72: invokevirtual #16 // Method java/lang/reflect/Method.invoke:(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; 75: pop 76: iinc 5, 1 79: goto 30 82: return
anewarray： 表示创建一个引用类型的（如类、接口、数组）数组，并将其引用值压如栈顶 (1: anewarray #2)
大致的分析：
1.绿色部分：反射调用分配了更多的栈，说明需要进行比普通调用还要多的栈空间分配，也就是pop出,push进。。
2.从方法体上看： 在反射部分代码中的蓝色背景部分，也就是62行字节码，使用了创建数组这一操作，并且还有68行的将int类型的1进行装箱操作，这些步骤对于普通调用来说，都是多出来的，自然也就比普通调用的方式耗时得多了。
但是，普通调用和反射调用一个方法的用途不一样，我们不能为了反射调用而调用，最好能够在普通调用无法满足的情况下进行该操作。
//五、优化反射调用
