《深入理解Java虚拟机》- JVM是如何实现反射的

邮差的信 提交于 2021-02-07 06:46:09

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进行装箱操作,这些步骤对于普通调用来说,都是多出来的,自然也就比普通调用的方式耗时得多了。

 

但是,普通调用和反射调用一个方法的用途不一样,我们不能为了反射调用而调用,最好能够在普通调用无法满足的情况下进行该操作。

 

//五、优化反射调用

 

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!